VK_POINT_CLIPPING_BEHAVIOR_LAST
};
-typedef enum VkPointClippingBehavior VkPointClippingBehaviorKHR;
-#define VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES
-#define VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY
enum VkTessellationDomainOrigin
{
VK_TESSELLATION_DOMAIN_ORIGIN_LAST
};
-typedef enum VkTessellationDomainOrigin VkTessellationDomainOriginKHR;
-#define VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT
-#define VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT
enum VkSamplerYcbcrModelConversion
{
VK_SAMPLER_YCBCR_MODEL_CONVERSION_LAST
};
-typedef enum VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
-#define VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY
-#define VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY
-#define VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709
-#define VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601
-#define VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020
enum VkSamplerYcbcrRange
{
VK_SAMPLER_YCBCR_RANGE_LAST
};
-typedef enum VkSamplerYcbcrRange VkSamplerYcbcrRangeKHR;
-#define VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR VK_SAMPLER_YCBCR_RANGE_ITU_FULL
-#define VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR VK_SAMPLER_YCBCR_RANGE_ITU_NARROW
enum VkChromaLocation
{
VK_CHROMA_LOCATION_LAST
};
-typedef enum VkChromaLocation VkChromaLocationKHR;
-#define VK_CHROMA_LOCATION_COSITED_EVEN_KHR VK_CHROMA_LOCATION_COSITED_EVEN
-#define VK_CHROMA_LOCATION_MIDPOINT_KHR VK_CHROMA_LOCATION_MIDPOINT
enum VkDescriptorUpdateTemplateType
{
VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_LAST
};
-typedef enum VkDescriptorUpdateTemplateType VkDescriptorUpdateTemplateTypeKHR;
-#define VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET
-#define VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS
enum VkColorSpaceKHR
{
VK_SUBGROUP_FEATURE_QUAD_BIT = 0x00000080,
};
typedef deUint32 VkSubgroupFeatureFlags;
-typedef VkSubgroupFeatureFlags VkSubgroupFeatureFlagsKHR;
-typedef VkSubgroupFeatureFlagBits VkSubgroupFeatureFlagBitsKHR;
-#define VK_SUBGROUP_FEATURE_BASIC_BIT_KHR VK_SUBGROUP_FEATURE_BASIC_BIT
-#define VK_SUBGROUP_FEATURE_VOTE_BIT_KHR VK_SUBGROUP_FEATURE_VOTE_BIT
-#define VK_SUBGROUP_FEATURE_ARITHMETIC_BIT_KHR VK_SUBGROUP_FEATURE_ARITHMETIC_BIT
-#define VK_SUBGROUP_FEATURE_BALLOT_BIT_KHR VK_SUBGROUP_FEATURE_BALLOT_BIT
-#define VK_SUBGROUP_FEATURE_SHUFFLE_BIT_KHR VK_SUBGROUP_FEATURE_SHUFFLE_BIT
-#define VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT_KHR VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT
-#define VK_SUBGROUP_FEATURE_CLUSTERED_BIT_KHR VK_SUBGROUP_FEATURE_CLUSTERED_BIT
-#define VK_SUBGROUP_FEATURE_QUAD_BIT_KHR VK_SUBGROUP_FEATURE_QUAD_BIT
enum VkPeerMemoryFeatureFlagBits
{
VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT = 0x00000008,
};
typedef deUint32 VkPeerMemoryFeatureFlags;
-typedef VkPeerMemoryFeatureFlags VkPeerMemoryFeatureFlagsKHR;
-typedef VkPeerMemoryFeatureFlagBits VkPeerMemoryFeatureFlagBitsKHR;
-#define VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT
-#define VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR VK_PEER_MEMORY_FEATURE_COPY_DST_BIT
-#define VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT
-#define VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT
enum VkMemoryAllocateFlagBits
{
VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT = 0x00000001,
};
typedef deUint32 VkMemoryAllocateFlags;
-typedef VkMemoryAllocateFlags VkMemoryAllocateFlagsKHR;
-typedef VkMemoryAllocateFlagBits VkMemoryAllocateFlagBitsKHR;
-#define VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT
enum VkExternalMemoryHandleTypeFlagBits
{
VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID = 0x00000080,
};
typedef deUint32 VkExternalMemoryHandleTypeFlags;
-typedef VkExternalMemoryHandleTypeFlags VkExternalMemoryHandleTypeFlagsKHR;
-typedef VkExternalMemoryHandleTypeFlagBits VkExternalMemoryHandleTypeFlagBitsKHR;
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT
-#define VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID_KHR VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID
enum VkExternalMemoryFeatureFlagBits
{
VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT = 0x00000004,
};
typedef deUint32 VkExternalMemoryFeatureFlags;
-typedef VkExternalMemoryFeatureFlags VkExternalMemoryFeatureFlagsKHR;
-typedef VkExternalMemoryFeatureFlagBits VkExternalMemoryFeatureFlagBitsKHR;
-#define VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT
-#define VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT
-#define VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT
enum VkExternalFenceHandleTypeFlagBits
{
VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000008,
};
typedef deUint32 VkExternalFenceHandleTypeFlags;
-typedef VkExternalFenceHandleTypeFlags VkExternalFenceHandleTypeFlagsKHR;
-typedef VkExternalFenceHandleTypeFlagBits VkExternalFenceHandleTypeFlagBitsKHR;
-#define VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT
-#define VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
-#define VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
-#define VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
enum VkExternalFenceFeatureFlagBits
{
VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT = 0x00000002,
};
typedef deUint32 VkExternalFenceFeatureFlags;
-typedef VkExternalFenceFeatureFlags VkExternalFenceFeatureFlagsKHR;
-typedef VkExternalFenceFeatureFlagBits VkExternalFenceFeatureFlagBitsKHR;
-#define VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT
-#define VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT
enum VkFenceImportFlagBits
{
VK_FENCE_IMPORT_TEMPORARY_BIT = 0x00000001,
};
typedef deUint32 VkFenceImportFlags;
-typedef VkFenceImportFlags VkFenceImportFlagsKHR;
-typedef VkFenceImportFlagBits VkFenceImportFlagBitsKHR;
-#define VK_FENCE_IMPORT_TEMPORARY_BIT_KHR VK_FENCE_IMPORT_TEMPORARY_BIT
enum VkSemaphoreImportFlagBits
{
VK_SEMAPHORE_IMPORT_TEMPORARY_BIT = 0x00000001,
};
typedef deUint32 VkSemaphoreImportFlags;
-typedef VkSemaphoreImportFlags VkSemaphoreImportFlagsKHR;
-typedef VkSemaphoreImportFlagBits VkSemaphoreImportFlagBitsKHR;
-#define VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR VK_SEMAPHORE_IMPORT_TEMPORARY_BIT
enum VkExternalSemaphoreHandleTypeFlagBits
{
VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT = 0x00000010,
};
typedef deUint32 VkExternalSemaphoreHandleTypeFlags;
-typedef VkExternalSemaphoreHandleTypeFlags VkExternalSemaphoreHandleTypeFlagsKHR;
-typedef VkExternalSemaphoreHandleTypeFlagBits VkExternalSemaphoreHandleTypeFlagBitsKHR;
-#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT
-#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
-#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
-#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT
-#define VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
enum VkExternalSemaphoreFeatureFlagBits
{
VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT = 0x00000002,
};
typedef deUint32 VkExternalSemaphoreFeatureFlags;
-typedef VkExternalSemaphoreFeatureFlags VkExternalSemaphoreFeatureFlagsKHR;
-typedef VkExternalSemaphoreFeatureFlagBits VkExternalSemaphoreFeatureFlagBitsKHR;
-#define VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT
-#define VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT
enum VkSurfaceTransformFlagBitsKHR
{
typedef deUint32 VkRenderPassCreateFlags;
typedef deUint32 VkCommandPoolTrimFlags;
-typedef VkCommandPoolTrimFlags VkCommandPoolTrimFlagsKHR;
typedef deUint32 VkDescriptorUpdateTemplateCreateFlags;
-typedef VkDescriptorUpdateTemplateCreateFlags VkDescriptorUpdateTemplateCreateFlagsKHR;
typedef deUint32 VkDisplayModeCreateFlagsKHR;
virtual VkResult queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const;
virtual VkResult acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, deUint32* pImageIndex) const;
virtual VkResult createSharedSwapchainsKHR (VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const;
-virtual void getDeviceGroupPeerMemoryFeaturesKHR (VkDevice device, deUint32 heapIndex, deUint32 localDeviceIndex, deUint32 remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const;
-virtual void cmdSetDeviceMaskKHR (VkCommandBuffer commandBuffer, deUint32 deviceMask) const;
-virtual void cmdDispatchBaseKHR (VkCommandBuffer commandBuffer, deUint32 baseGroupX, deUint32 baseGroupY, deUint32 baseGroupZ, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ) const;
-virtual void trimCommandPoolKHR (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const;
virtual VkResult getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const;
virtual VkResult getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const;
virtual VkResult getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const;
virtual VkResult getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const;
virtual void cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const;
virtual void cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const;
-virtual VkResult createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const;
-virtual void destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const;
-virtual void updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const;
virtual VkResult getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const;
virtual VkResult importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) const;
virtual VkResult getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const;
virtual VkResult importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const;
virtual VkResult getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const;
-virtual void getDeviceQueue2KHR (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const;
-virtual void getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const;
-virtual void getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const;
-virtual void getImageSparseMemoryRequirements2KHR (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const;
-virtual VkResult createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const;
-virtual void destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const;
-virtual VkResult bindBufferMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const;
-virtual VkResult bindImageMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const;
-virtual void getDescriptorSetLayoutSupportKHR (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const;
virtual VkResult debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const;
virtual VkResult debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const;
virtual void cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const;
virtual VkResult createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const;
virtual VkResult createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const;
virtual VkBool32 getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex) const;
-virtual void getPhysicalDeviceFeatures2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const;
-virtual void getPhysicalDeviceProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const;
-virtual void getPhysicalDeviceFormatProperties2KHR (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const;
-virtual VkResult getPhysicalDeviceImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const;
-virtual void getPhysicalDeviceQueueFamilyProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const;
-virtual void getPhysicalDeviceMemoryProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const;
-virtual void getPhysicalDeviceSparseImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const;
-virtual VkResult enumeratePhysicalDeviceGroupsKHR (VkInstance instance, deUint32* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const;
-virtual void getPhysicalDeviceExternalBufferPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const;
-virtual void getPhysicalDeviceExternalSemaphorePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const;
-virtual void getPhysicalDeviceExternalFencePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const;
virtual VkResult getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const;
virtual VkResult getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const;
virtual VkResult getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) const;
return m_vk.createSharedSwapchainsKHR(device, swapchainCount, pCreateInfos, pAllocator, pSwapchains);
}
-void DeviceDriver::getDeviceGroupPeerMemoryFeaturesKHR (VkDevice device, deUint32 heapIndex, deUint32 localDeviceIndex, deUint32 remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const
-{
- m_vk.getDeviceGroupPeerMemoryFeatures(device, heapIndex, localDeviceIndex, remoteDeviceIndex, pPeerMemoryFeatures);
-}
-
-void DeviceDriver::cmdSetDeviceMaskKHR (VkCommandBuffer commandBuffer, deUint32 deviceMask) const
-{
- m_vk.cmdSetDeviceMask(commandBuffer, deviceMask);
-}
-
-void DeviceDriver::cmdDispatchBaseKHR (VkCommandBuffer commandBuffer, deUint32 baseGroupX, deUint32 baseGroupY, deUint32 baseGroupZ, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ) const
-{
- m_vk.cmdDispatchBase(commandBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
-}
-
-void DeviceDriver::trimCommandPoolKHR (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const
-{
- m_vk.trimCommandPool(device, commandPool, flags);
-}
-
VkResult DeviceDriver::getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const
{
return m_vk.getMemoryWin32HandleKHR(device, pGetWin32HandleInfo, pHandle);
m_vk.cmdPushDescriptorSetWithTemplateKHR(commandBuffer, descriptorUpdateTemplate, layout, set, pData);
}
-VkResult DeviceDriver::createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const
-{
- return m_vk.createDescriptorUpdateTemplate(device, pCreateInfo, pAllocator, pDescriptorUpdateTemplate);
-}
-
-void DeviceDriver::destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const
-{
- m_vk.destroyDescriptorUpdateTemplate(device, descriptorUpdateTemplate, pAllocator);
-}
-
-void DeviceDriver::updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const
-{
- m_vk.updateDescriptorSetWithTemplate(device, descriptorSet, descriptorUpdateTemplate, pData);
-}
-
VkResult DeviceDriver::getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const
{
return m_vk.getSwapchainStatusKHR(device, swapchain);
return m_vk.getFenceFdKHR(device, pGetFdInfo, pFd);
}
-void DeviceDriver::getDeviceQueue2KHR (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const
-{
- m_vk.getDeviceQueue2(device, pQueueInfo, pQueue);
-}
-
-void DeviceDriver::getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
-{
- m_vk.getImageMemoryRequirements2(device, pInfo, pMemoryRequirements);
-}
-
-void DeviceDriver::getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const
-{
- m_vk.getBufferMemoryRequirements2(device, pInfo, pMemoryRequirements);
-}
-
-void DeviceDriver::getImageSparseMemoryRequirements2KHR (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const
-{
- m_vk.getImageSparseMemoryRequirements2(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
-}
-
-VkResult DeviceDriver::createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const
-{
- return m_vk.createSamplerYcbcrConversion(device, pCreateInfo, pAllocator, pYcbcrConversion);
-}
-
-void DeviceDriver::destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const
-{
- m_vk.destroySamplerYcbcrConversion(device, ycbcrConversion, pAllocator);
-}
-
-VkResult DeviceDriver::bindBufferMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const
-{
- return m_vk.bindBufferMemory2(device, bindInfoCount, pBindInfos);
-}
-
-VkResult DeviceDriver::bindImageMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const
-{
- return m_vk.bindImageMemory2(device, bindInfoCount, pBindInfos);
-}
-
-void DeviceDriver::getDescriptorSetLayoutSupportKHR (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const
-{
- m_vk.getDescriptorSetLayoutSupport(device, pCreateInfo, pSupport);
-}
-
VkResult DeviceDriver::debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const
{
return m_vk.debugMarkerSetObjectTagEXT(device, pTagInfo);
return m_vk.getPhysicalDeviceWin32PresentationSupportKHR(physicalDevice, queueFamilyIndex);
}
-void InstanceDriver::getPhysicalDeviceFeatures2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const
-{
- m_vk.getPhysicalDeviceFeatures2(physicalDevice, pFeatures);
-}
-
-void InstanceDriver::getPhysicalDeviceProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const
-{
- m_vk.getPhysicalDeviceProperties2(physicalDevice, pProperties);
-}
-
-void InstanceDriver::getPhysicalDeviceFormatProperties2KHR (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const
-{
- m_vk.getPhysicalDeviceFormatProperties2(physicalDevice, format, pFormatProperties);
-}
-
-VkResult InstanceDriver::getPhysicalDeviceImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const
-{
- return m_vk.getPhysicalDeviceImageFormatProperties2(physicalDevice, pImageFormatInfo, pImageFormatProperties);
-}
-
-void InstanceDriver::getPhysicalDeviceQueueFamilyProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const
-{
- m_vk.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties);
-}
-
-void InstanceDriver::getPhysicalDeviceMemoryProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const
-{
- m_vk.getPhysicalDeviceMemoryProperties2(physicalDevice, pMemoryProperties);
-}
-
-void InstanceDriver::getPhysicalDeviceSparseImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const
-{
- m_vk.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, pFormatInfo, pPropertyCount, pProperties);
-}
-
-VkResult InstanceDriver::enumeratePhysicalDeviceGroupsKHR (VkInstance instance, deUint32* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const
-{
- return m_vk.enumeratePhysicalDeviceGroups(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties);
-}
-
-void InstanceDriver::getPhysicalDeviceExternalBufferPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const
-{
- m_vk.getPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties);
-}
-
-void InstanceDriver::getPhysicalDeviceExternalSemaphorePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const
-{
- m_vk.getPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties);
-}
-
-void InstanceDriver::getPhysicalDeviceExternalFencePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const
-{
- m_vk.getPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties);
-}
-
VkResult InstanceDriver::getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const
{
return m_vk.getPhysicalDeviceSurfaceCapabilities2KHR(physicalDevice, pSurfaceInfo, pSurfaceCapabilities);
const VkBuffer buffer,
MemoryRequirement requirement)
{
- const VkMemoryRequirements memoryRequirements = getBufferMemoryRequirements(vkd, device, buffer);
- const VkMemoryDedicatedAllocateInfoKHR dedicatedAllocationInfo =
+ const VkMemoryRequirements memoryRequirements = getBufferMemoryRequirements(vkd, device, buffer);
+ const VkMemoryDedicatedAllocateInfo dedicatedAllocationInfo =
{
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
MemoryRequirement requirement)
{
const VkMemoryRequirements memoryRequirements = getImageMemoryRequirements(vkd, device, image);
- const VkMemoryDedicatedAllocateInfoKHR dedicatedAllocationInfo =
+ const VkMemoryDedicatedAllocateInfo dedicatedAllocationInfo =
{
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VkDeviceSize memoryOffset,
VkImageAspectFlagBits planeAspect)
{
- const VkBindImagePlaneMemoryInfoKHR planeInfo =
+ const VkBindImagePlaneMemoryInfo planeInfo =
{
VK_STRUCTURE_TYPE_BIND_IMAGE_PLANE_MEMORY_INFO_KHR,
DE_NULL,
planeAspect
};
- const VkBindImageMemoryInfoKHR coreInfo =
+ const VkBindImageMemoryInfo coreInfo =
{
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR,
&planeInfo,
memoryOffset,
};
- VK_CHECK(vkd.bindImageMemory2KHR(device, 1u, &coreInfo));
+ VK_CHECK(vkd.bindImageMemory2(device, 1u, &coreInfo));
}
} // vk
const VkDeviceSize m_size;
};
-VkExternalMemoryHandleTypeFlagsKHR getExternalTypesHandle (const VkImageCreateInfo* pCreateInfo)
+VkExternalMemoryHandleTypeFlags getExternalTypesHandle (const VkImageCreateInfo* pCreateInfo)
{
- const VkExternalMemoryImageCreateInfoKHR* const externalInfo = findStructure<VkExternalMemoryImageCreateInfoKHR> (pCreateInfo->pNext);
+ const VkExternalMemoryImageCreateInfo* const externalInfo = findStructure<VkExternalMemoryImageCreateInfo> (pCreateInfo->pNext);
return externalInfo ? externalInfo->handleTypes : 0u;
}
VkSampleCountFlagBits getSamples (void) const { return m_samples; }
VkImageUsageFlags getUsage (void) const { return m_usage; }
VkImageCreateFlags getFlags (void) const { return m_flags; }
- VkExternalMemoryHandleTypeFlagsKHR getExternalHandleTypes (void) const { return m_externalHandleTypes; }
+ VkExternalMemoryHandleTypeFlags getExternalHandleTypes (void) const { return m_externalHandleTypes; }
private:
const VkImageType m_imageType;
const VkSampleCountFlagBits m_samples;
const VkImageUsageFlags m_usage;
const VkImageCreateFlags m_flags;
- const VkExternalMemoryHandleTypeFlagsKHR m_externalHandleTypes;
+ const VkExternalMemoryHandleTypeFlags m_externalHandleTypes;
};
void* allocateHeap (const VkMemoryAllocateInfo* pAllocInfo)
#if defined(USE_ANDROID_O_HARDWARE_BUFFER)
AHardwareBuffer* findOrCreateHwBuffer (const VkMemoryAllocateInfo* pAllocInfo)
{
- const VkExportMemoryAllocateInfoKHR* const exportInfo = findStructure<VkExportMemoryAllocateInfoKHR>(pAllocInfo->pNext);
+ const VkExportMemoryAllocateInfo* const exportInfo = findStructure<VkExportMemoryAllocateInfo>(pAllocInfo->pNext);
const VkImportAndroidHardwareBufferInfoANDROID* const importInfo = findStructure<VkImportAndroidHardwareBufferInfoANDROID>(pAllocInfo->pNext);
- const VkMemoryDedicatedAllocateInfoKHR* const dedicatedInfo = findStructure<VkMemoryDedicatedAllocateInfoKHR>(pAllocInfo->pNext);
+ const VkMemoryDedicatedAllocateInfo* const dedicatedInfo = findStructure<VkMemoryDedicatedAllocateInfo>(pAllocInfo->pNext);
const Image* const image = dedicatedInfo && !!dedicatedInfo->image ? reinterpret_cast<const Image*>(dedicatedInfo->image.getInternal()) : DE_NULL;
AHardwareBuffer* hwbuffer = DE_NULL;
hwbufferDesc.usage |= AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE;
if ((image->getUsage() & VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT) != 0)
hwbufferDesc.usage |= AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT;
- // if ((image->getFlags() & VK_IMAGE_CREATE_PROTECTED_BIT_KHR) != 0)
+ // if ((image->getFlags() & VK_IMAGE_CREATE_PROTECTED_BIT) != 0)
// hwbufferDesc.usage |= AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT;
// Make sure we have at least one AHB GPU usage, even if the image doesn't have any
pFeatures->inheritedQueries = VK_TRUE;
}
-VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceFeatures2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2KHR* pFeatures)
-{
- // Core features
- getPhysicalDeviceFeatures(physicalDevice, &pFeatures->features);
-
- // VK_KHR_sampler_ycbcr_conversion
- {
- VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR* extFeatures = findStructure<VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR>(pFeatures->pNext);
-
- if (extFeatures)
- extFeatures->samplerYcbcrConversion = VK_TRUE;
- }
-}
-
VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties (VkPhysicalDevice, VkPhysicalDeviceProperties* props)
{
deMemset(props, 0, sizeof(VkPhysicalDeviceProperties));
props->limits.nonCoherentAtomSize = 128;
}
-
-VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2KHR* pProperties)
-{
- getPhysicalDeviceProperties(physicalDevice, &pProperties->properties);
-}
-
VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceQueueFamilyProperties (VkPhysicalDevice, deUint32* count, VkQueueFamilyProperties* props)
{
if (props && *count >= 1u)
| VK_FORMAT_FEATURE_BLIT_SRC_BIT
| VK_FORMAT_FEATURE_BLIT_DST_BIT
| VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT
- | VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR
- | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR
- | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR
- | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR
- | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR
- | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR;
+ | VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT
+ | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
pFormatProperties->linearTilingFeatures = allFeatures;
pFormatProperties->optimalTilingFeatures = allFeatures;
pFormatProperties->bufferFeatures = allFeatures;
if (isYCbCrFormat(format) && getPlaneCount(format) > 1)
- pFormatProperties->optimalTilingFeatures |= VK_FORMAT_FEATURE_DISJOINT_BIT_KHR;
+ pFormatProperties->optimalTilingFeatures |= VK_FORMAT_FEATURE_DISJOINT_BIT;
}
VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties (VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
requirements->alignment = (VkDeviceSize)1u;
}
-VKAPI_ATTR void VKAPI_CALL getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
-{
- getBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements);
-}
-
VkDeviceSize getPackedImageDataSize (VkFormat format, VkExtent3D extent, VkSampleCountFlagBits samples)
{
return (VkDeviceSize)getPixelSize(mapVkFormat(format))
requirements->size = getPackedImageDataSize(image->getFormat(), image->getExtent(), image->getSamples());
}
-VKAPI_ATTR void VKAPI_CALL getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2KHR* pInfo, VkMemoryRequirements2KHR* pMemoryRequirements)
-{
- const VkImagePlaneMemoryRequirementsInfoKHR* const planeReqs = findStructure<VkImagePlaneMemoryRequirementsInfoKHR>(pInfo->pNext);
- VkMemoryDedicatedRequirementsKHR* const dedicatedReqs = findStructure<VkMemoryDedicatedRequirementsKHR>(pMemoryRequirements->pNext);
-
- if (planeReqs)
- {
- const deUint32 planeNdx = getAspectPlaneNdx(planeReqs->planeAspect);
- const Image* const image = reinterpret_cast<const Image*>(pInfo->image.getInternal());
- const VkFormat format = image->getFormat();
- const PlanarFormatDescription formatDesc = getPlanarFormatDescription(format);
-
- DE_ASSERT(de::inBounds<deUint32>(planeNdx, 0u, formatDesc.numPlanes));
-
- const VkExtent3D extent = image->getExtent();
- const deUint32 planeW = extent.width / formatDesc.planes[planeNdx].widthDivisor;
- const deUint32 planeH = extent.height / formatDesc.planes[planeNdx].heightDivisor;
- const deUint32 elementSize = formatDesc.planes[planeNdx].elementSizeBytes;
-
- pMemoryRequirements->memoryRequirements.memoryTypeBits = 1u;
- pMemoryRequirements->memoryRequirements.alignment = 16u;
- pMemoryRequirements->memoryRequirements.size = planeW * planeH * elementSize;
- }
- else
- getImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements);
-
- if (dedicatedReqs)
- {
- const Image* const image = reinterpret_cast<const Image*>(pInfo->image.getInternal());
- VkExternalMemoryHandleTypeFlagsKHR externalHandleTypes = image->getExternalHandleTypes();
-
- dedicatedReqs->prefersDedicatedAllocation = VK_FALSE;
-
- if ((externalHandleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) != 0)
- dedicatedReqs->requiresDedicatedAllocation = VK_TRUE;
- else
- dedicatedReqs->requiresDedicatedAllocation = VK_FALSE;
- }
-}
-
VKAPI_ATTR VkResult VKAPI_CALL allocateMemory (VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
{
- const VkExportMemoryAllocateInfoKHR* const exportInfo = findStructure<VkExportMemoryAllocateInfoKHR>(pAllocateInfo->pNext);
+ const VkExportMemoryAllocateInfo* const exportInfo = findStructure<VkExportMemoryAllocateInfo>(pAllocateInfo->pNext);
const VkImportAndroidHardwareBufferInfoANDROID* const importInfo = findStructure<VkImportAndroidHardwareBufferInfoANDROID>(pAllocateInfo->pNext);
if ((exportInfo && (exportInfo->handleTypes & VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID) != 0)
return VK_SUCCESS;
}
-VKAPI_ATTR void VKAPI_CALL getPhysicalDeviceExternalBufferPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfoKHR* pExternalBufferInfo, VkExternalBufferPropertiesKHR* pExternalBufferProperties)
-{
- DE_UNREF(physicalDevice);
- DE_UNREF(pExternalBufferInfo);
-
- pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0;
- pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0;
- pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = 0;
-
-#if defined(USE_ANDROID_O_HARDWARE_BUFFER)
- if (pExternalBufferInfo->handleType == VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
- {
- pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR | VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
- pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
- pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
- }
-#endif
-}
-
-VKAPI_ATTR VkResult VKAPI_CALL getPhysicalDeviceImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR* pImageFormatInfo, VkImageFormatProperties2KHR* pImageFormatProperties)
-{
- const VkPhysicalDeviceExternalImageFormatInfoKHR* const externalInfo = findStructure<VkPhysicalDeviceExternalImageFormatInfoKHR>(pImageFormatInfo->pNext);
- VkExternalImageFormatPropertiesKHR* const externalProperties = findStructure<VkExternalImageFormatPropertiesKHR>(pImageFormatProperties->pNext);
- VkResult result;
-
- result = getPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties);
- if (result != VK_SUCCESS)
- return result;
-
- if (externalInfo && externalInfo->handleType != 0)
- {
-#if defined(USE_ANDROID_O_HARDWARE_BUFFER)
- if (externalInfo->handleType != VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID)
- return VK_ERROR_FORMAT_NOT_SUPPORTED;
-
- if (!(pImageFormatInfo->format == VK_FORMAT_R8G8B8A8_UNORM
- || pImageFormatInfo->format == VK_FORMAT_R8G8B8_UNORM
- || pImageFormatInfo->format == VK_FORMAT_R5G6B5_UNORM_PACK16
- || pImageFormatInfo->format == VK_FORMAT_R16G16B16A16_SFLOAT
- || pImageFormatInfo->format == VK_FORMAT_A2R10G10B10_UNORM_PACK32))
- {
- return VK_ERROR_FORMAT_NOT_SUPPORTED;
- }
-
- if (pImageFormatInfo->type != VK_IMAGE_TYPE_2D)
- return VK_ERROR_FORMAT_NOT_SUPPORTED;
-
- if ((pImageFormatInfo->usage & ~(VK_IMAGE_USAGE_TRANSFER_SRC_BIT
- | VK_IMAGE_USAGE_TRANSFER_DST_BIT
- | VK_IMAGE_USAGE_SAMPLED_BIT
- | VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT))
- != 0)
- {
- return VK_ERROR_FORMAT_NOT_SUPPORTED;
- }
-
- if ((pImageFormatInfo->flags & ~(VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
- /*| VK_IMAGE_CREATE_PROTECTED_BIT_KHR*/
- /*| VK_IMAGE_CREATE_EXTENDED_USAGE_BIT_KHR*/))
- != 0)
- {
- return VK_ERROR_FORMAT_NOT_SUPPORTED;
- }
-
- if (externalProperties)
- {
- externalProperties->externalMemoryProperties.externalMemoryFeatures = VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR
- | VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR
- | VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR;
- externalProperties->externalMemoryProperties.exportFromImportedHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
- externalProperties->externalMemoryProperties.compatibleHandleTypes = VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID;
- }
-#else
- DE_UNREF(externalProperties);
- return VK_ERROR_FORMAT_NOT_SUPPORTED;
-#endif
- }
-
- return VK_SUCCESS;
-}
-
// \note getInstanceProcAddr is a little bit special:
// vkNullDriverImpl.inl needs it to define s_platformFunctions but
// getInstanceProcAddr() implementation needs other entry points from
return devices;
}
-vector<VkPhysicalDeviceGroupPropertiesKHR> enumeratePhysicalDeviceGroupsKHR(const InstanceInterface& vk, VkInstance instance)
+vector<VkPhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups(const InstanceInterface& vk, VkInstance instance)
{
- deUint32 numDeviceGroups = 0;
- vector<VkPhysicalDeviceGroupPropertiesKHR> properties;
+ deUint32 numDeviceGroups = 0;
+ vector<VkPhysicalDeviceGroupProperties> properties;
- VK_CHECK(vk.enumeratePhysicalDeviceGroupsKHR(instance, &numDeviceGroups, DE_NULL));
+ VK_CHECK(vk.enumeratePhysicalDeviceGroups(instance, &numDeviceGroups, DE_NULL));
if (numDeviceGroups > 0)
{
properties[i].sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_GROUP_PROPERTIES_KHR;
properties[i].pNext = DE_NULL;
}
- VK_CHECK(vk.enumeratePhysicalDeviceGroupsKHR(instance, &numDeviceGroups, &properties[0]));
+ VK_CHECK(vk.enumeratePhysicalDeviceGroups(instance, &numDeviceGroups, &properties[0]));
if ((size_t)numDeviceGroups != properties.size())
TCU_FAIL("Returned device group count changed between queries");
VkPhysicalDeviceFeatures2 features;
deMemset(&features, 0, sizeof(features));
- features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
- vk.getPhysicalDeviceFeatures2KHR(physicalDevice, &features);
+ vk.getPhysicalDeviceFeatures2(physicalDevice, &features);
return features;
}
VkImage image,
VkImageAspectFlagBits planeAspect)
{
- VkImageMemoryRequirementsInfo2KHR coreInfo;
- VkImagePlaneMemoryRequirementsInfoKHR planeInfo;
- VkMemoryRequirements2KHR reqs;
+ VkImageMemoryRequirementsInfo2 coreInfo;
+ VkImagePlaneMemoryRequirementsInfo planeInfo;
+ VkMemoryRequirements2 reqs;
deMemset(&coreInfo, 0, sizeof(coreInfo));
deMemset(&planeInfo, 0, sizeof(planeInfo));
reqs.sType = VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR;
- vkd.getImageMemoryRequirements2KHR(device, &coreInfo, &reqs);
+ vkd.getImageMemoryRequirements2(device, &coreInfo, &reqs);
return reqs.memoryRequirements;
}
return queue;
}
-VkQueue getDeviceQueue2KHR (const DeviceInterface& vkd, VkDevice device, const VkDeviceQueueInfo2KHR* queueInfo)
+VkQueue getDeviceQueue2 (const DeviceInterface& vkd, VkDevice device, const VkDeviceQueueInfo2* queueInfo)
{
VkQueue queue;
- vkd.getDeviceQueue2KHR(device, queueInfo, &queue);
+ vkd.getDeviceQueue2(device, queueInfo, &queue);
return queue;
}
// API queries
std::vector<VkPhysicalDevice> enumeratePhysicalDevices (const InstanceInterface& vk, VkInstance instance);
-std::vector<VkPhysicalDeviceGroupPropertiesKHR> enumeratePhysicalDeviceGroupsKHR (const InstanceInterface& vk, VkInstance instance);
+std::vector<VkPhysicalDeviceGroupProperties> enumeratePhysicalDeviceGroups (const InstanceInterface& vk, VkInstance instance);
std::vector<VkQueueFamilyProperties> getPhysicalDeviceQueueFamilyProperties (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
VkPhysicalDeviceFeatures getPhysicalDeviceFeatures (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
VkPhysicalDeviceFeatures2 getPhysicalDeviceFeatures2 (const InstanceInterface& vk, VkPhysicalDevice physicalDevice);
std::vector<VkExtensionProperties> enumerateDeviceExtensionProperties (const InstanceInterface& vki, VkPhysicalDevice physicalDevice, const char* layerName);
VkQueue getDeviceQueue (const DeviceInterface& vkd, VkDevice device, deUint32 queueFamilyIndex, deUint32 queueIndex);
-VkQueue getDeviceQueue2KHR (const DeviceInterface& vkd, VkDevice device, const VkDeviceQueueInfo2KHR *queueInfo);
+VkQueue getDeviceQueue2 (const DeviceInterface& vkd, VkDevice device, const VkDeviceQueueInfo2 *queueInfo);
// Feature / extension support
/* WARNING: This is auto-generated file. Do not modify, since changes will
* be lost! Modify the generating script instead.
*/
-Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkDeviceMemory> allocateMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkCommandPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSamplerYcbcrConversion> createSamplerYcbcrConversion (const DeviceInterface& vk, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkDescriptorUpdateTemplate> createDescriptorUpdateTemplate (const DeviceInterface& vk, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSwapchainKHR> createSwapchainKHR (const DeviceInterface& vk, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createDisplayPlaneSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSwapchainKHR> createSharedSwapchainsKHR (const DeviceInterface& vk, VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createXlibSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createXcbSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createWaylandSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createMirSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createAndroidSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createWin32SurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkDescriptorUpdateTemplate> createDescriptorUpdateTemplateKHR (const DeviceInterface& vk, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSamplerYcbcrConversion> createSamplerYcbcrConversionKHR (const DeviceInterface& vk, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkDebugReportCallbackEXT> createDebugReportCallbackEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createViSurfaceNN (const InstanceInterface& vk, VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkIndirectCommandsLayoutNVX> createIndirectCommandsLayoutNVX (const DeviceInterface& vk, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkObjectTableNVX> createObjectTableNVX (const DeviceInterface& vk, VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createIOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkSurfaceKHR> createMacOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
-Move<VkValidationCacheEXT> createValidationCacheEXT (const DeviceInterface& vk, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkInstance> createInstance (const PlatformInterface& vk, const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDevice> createDevice (const InstanceInterface& vk, VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDeviceMemory> allocateMemory (const DeviceInterface& vk, VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkFence> createFence (const DeviceInterface& vk, VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSemaphore> createSemaphore (const DeviceInterface& vk, VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkEvent> createEvent (const DeviceInterface& vk, VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkQueryPool> createQueryPool (const DeviceInterface& vk, VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkBuffer> createBuffer (const DeviceInterface& vk, VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkBufferView> createBufferView (const DeviceInterface& vk, VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkImage> createImage (const DeviceInterface& vk, VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkImageView> createImageView (const DeviceInterface& vk, VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkShaderModule> createShaderModule (const DeviceInterface& vk, VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkPipelineCache> createPipelineCache (const DeviceInterface& vk, VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkPipelineLayout> createPipelineLayout (const DeviceInterface& vk, VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSampler> createSampler (const DeviceInterface& vk, VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDescriptorSetLayout> createDescriptorSetLayout (const DeviceInterface& vk, VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDescriptorPool> createDescriptorPool (const DeviceInterface& vk, VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkFramebuffer> createFramebuffer (const DeviceInterface& vk, VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkRenderPass> createRenderPass (const DeviceInterface& vk, VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkCommandPool> createCommandPool (const DeviceInterface& vk, VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSamplerYcbcrConversion> createSamplerYcbcrConversion (const DeviceInterface& vk, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDescriptorUpdateTemplate> createDescriptorUpdateTemplate (const DeviceInterface& vk, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSwapchainKHR> createSwapchainKHR (const DeviceInterface& vk, VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createDisplayPlaneSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSwapchainKHR> createSharedSwapchainsKHR (const DeviceInterface& vk, VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createXlibSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXlibSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createXcbSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkXcbSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createWaylandSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createMirSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkMirSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createAndroidSurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createWin32SurfaceKHR (const InstanceInterface& vk, VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkDebugReportCallbackEXT> createDebugReportCallbackEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createViSurfaceNN (const InstanceInterface& vk, VkInstance instance, const VkViSurfaceCreateInfoNN* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkIndirectCommandsLayoutNVX> createIndirectCommandsLayoutNVX (const DeviceInterface& vk, VkDevice device, const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkObjectTableNVX> createObjectTableNVX (const DeviceInterface& vk, VkDevice device, const VkObjectTableCreateInfoNVX* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createIOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkIOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkSurfaceKHR> createMacOSSurfaceMVK (const InstanceInterface& vk, VkInstance instance, const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
+Move<VkValidationCacheEXT> createValidationCacheEXT (const DeviceInterface& vk, VkDevice device, const VkValidationCacheCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator = DE_NULL);
return Move<VkSurfaceKHR>(check<VkSurfaceKHR>(object), Deleter<VkSurfaceKHR>(vk, instance, pAllocator));
}
-Move<VkDescriptorUpdateTemplate> createDescriptorUpdateTemplateKHR (const DeviceInterface& vk, VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
-{
- VkDescriptorUpdateTemplate object = 0;
- VK_CHECK(vk.createDescriptorUpdateTemplateKHR(device, pCreateInfo, pAllocator, &object));
- return Move<VkDescriptorUpdateTemplate>(check<VkDescriptorUpdateTemplate>(object), Deleter<VkDescriptorUpdateTemplate>(vk, device, pAllocator));
-}
-
-Move<VkSamplerYcbcrConversion> createSamplerYcbcrConversionKHR (const DeviceInterface& vk, VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator)
-{
- VkSamplerYcbcrConversion object = 0;
- VK_CHECK(vk.createSamplerYcbcrConversionKHR(device, pCreateInfo, pAllocator, &object));
- return Move<VkSamplerYcbcrConversion>(check<VkSamplerYcbcrConversion>(object), Deleter<VkSamplerYcbcrConversion>(vk, device, pAllocator));
-}
-
Move<VkDebugReportCallbackEXT> createDebugReportCallbackEXT (const InstanceInterface& vk, VkInstance instance, const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, const VkAllocationCallbacks* pAllocator)
{
VkDebugReportCallbackEXT object = 0;
}
}
-const char* getPointClippingBehaviorKHRName (VkPointClippingBehaviorKHR value)
-{
- switch (value)
- {
- case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: return "VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES";
- case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: return "VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY";
- default: return DE_NULL;
- }
-}
-
-const char* getTessellationDomainOriginKHRName (VkTessellationDomainOriginKHR value)
-{
- switch (value)
- {
- case VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT: return "VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT";
- case VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT: return "VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT";
- default: return DE_NULL;
- }
-}
-
-const char* getSamplerYcbcrModelConversionKHRName (VkSamplerYcbcrModelConversionKHR value)
-{
- switch (value)
- {
- case VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY";
- case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY";
- case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709";
- case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601";
- case VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020: return "VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020";
- default: return DE_NULL;
- }
-}
-
-const char* getSamplerYcbcrRangeKHRName (VkSamplerYcbcrRangeKHR value)
-{
- switch (value)
- {
- case VK_SAMPLER_YCBCR_RANGE_ITU_FULL: return "VK_SAMPLER_YCBCR_RANGE_ITU_FULL";
- case VK_SAMPLER_YCBCR_RANGE_ITU_NARROW: return "VK_SAMPLER_YCBCR_RANGE_ITU_NARROW";
- default: return DE_NULL;
- }
-}
-
-const char* getChromaLocationKHRName (VkChromaLocationKHR value)
-{
- switch (value)
- {
- case VK_CHROMA_LOCATION_COSITED_EVEN: return "VK_CHROMA_LOCATION_COSITED_EVEN";
- case VK_CHROMA_LOCATION_MIDPOINT: return "VK_CHROMA_LOCATION_MIDPOINT";
- default: return DE_NULL;
- }
-}
-
-const char* getDescriptorUpdateTemplateTypeKHRName (VkDescriptorUpdateTemplateTypeKHR value)
-{
- switch (value)
- {
- case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET: return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET";
- case VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS: return "VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS";
- default: return DE_NULL;
- }
-}
-
tcu::Format::Bitfield<32> getFormatFeatureFlagsStr (VkFormatFeatureFlags value)
{
static const tcu::Format::BitDesc s_desc[] =
return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
}
-tcu::Format::Bitfield<32> getCommandPoolTrimFlagsKHRStr (VkCommandPoolTrimFlagsKHR value)
-{
- return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
-}
-
tcu::Format::Bitfield<32> getDescriptorUpdateTemplateCreateFlagsStr (VkDescriptorUpdateTemplateCreateFlags value)
{
return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
}
-tcu::Format::Bitfield<32> getSubgroupFeatureFlagsKHRStr (VkSubgroupFeatureFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_BASIC_BIT, "VK_SUBGROUP_FEATURE_BASIC_BIT"),
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_VOTE_BIT, "VK_SUBGROUP_FEATURE_VOTE_BIT"),
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_ARITHMETIC_BIT, "VK_SUBGROUP_FEATURE_ARITHMETIC_BIT"),
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_BALLOT_BIT, "VK_SUBGROUP_FEATURE_BALLOT_BIT"),
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_SHUFFLE_BIT, "VK_SUBGROUP_FEATURE_SHUFFLE_BIT"),
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT, "VK_SUBGROUP_FEATURE_SHUFFLE_RELATIVE_BIT"),
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_CLUSTERED_BIT, "VK_SUBGROUP_FEATURE_CLUSTERED_BIT"),
- tcu::Format::BitDesc(VK_SUBGROUP_FEATURE_QUAD_BIT, "VK_SUBGROUP_FEATURE_QUAD_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getPeerMemoryFeatureFlagsKHRStr (VkPeerMemoryFeatureFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT, "VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT"),
- tcu::Format::BitDesc(VK_PEER_MEMORY_FEATURE_COPY_DST_BIT, "VK_PEER_MEMORY_FEATURE_COPY_DST_BIT"),
- tcu::Format::BitDesc(VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT, "VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT"),
- tcu::Format::BitDesc(VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT, "VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getMemoryAllocateFlagsKHRStr (VkMemoryAllocateFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, "VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getExternalMemoryHandleTypeFlagsKHRStr (VkExternalMemoryHandleTypeFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID, "VK_EXTERNAL_MEMORY_HANDLE_TYPE_ANDROID_HARDWARE_BUFFER_BIT_ANDROID"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getExternalMemoryFeatureFlagsKHRStr (VkExternalMemoryFeatureFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT, "VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT, "VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT, "VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getExternalFenceHandleTypeFlagsKHRStr (VkExternalFenceHandleTypeFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT, "VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getExternalFenceFeatureFlagsKHRStr (VkExternalFenceFeatureFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT, "VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT, "VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getFenceImportFlagsKHRStr (VkFenceImportFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_FENCE_IMPORT_TEMPORARY_BIT, "VK_FENCE_IMPORT_TEMPORARY_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getSemaphoreImportFlagsKHRStr (VkSemaphoreImportFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_SEMAPHORE_IMPORT_TEMPORARY_BIT, "VK_SEMAPHORE_IMPORT_TEMPORARY_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getExternalSemaphoreHandleTypeFlagsKHRStr (VkExternalSemaphoreHandleTypeFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT, "VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getExternalSemaphoreFeatureFlagsKHRStr (VkExternalSemaphoreFeatureFlagsKHR value)
-{
- static const tcu::Format::BitDesc s_desc[] =
- {
- tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT, "VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT"),
- tcu::Format::BitDesc(VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT, "VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT"),
- };
- return tcu::Format::Bitfield<32>(value, DE_ARRAY_BEGIN(s_desc), DE_ARRAY_END(s_desc));
-}
-
-tcu::Format::Bitfield<32> getDescriptorUpdateTemplateCreateFlagsKHRStr (VkDescriptorUpdateTemplateCreateFlagsKHR value)
-{
- return tcu::Format::Bitfield<32>(value, DE_NULL, DE_NULL);
-}
-
std::ostream& operator<< (std::ostream& s, const VkApplicationInfo& value)
{
s << "VkApplicationInfo = {\n";
VkSubgroupFeatureFlags supportedOperations;
VkBool32 quadOperationsInAllStages;
};
-typedef VkPhysicalDeviceSubgroupProperties VkPhysicalDeviceSubgroupPropertiesKHR;
struct VkBindBufferMemoryInfo
{
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
};
-typedef VkBindBufferMemoryInfo VkBindBufferMemoryInfoKHR;
struct VkBindImageMemoryInfo
{
VkDeviceMemory memory;
VkDeviceSize memoryOffset;
};
-typedef VkBindImageMemoryInfo VkBindImageMemoryInfoKHR;
struct VkPhysicalDevice16BitStorageFeatures
{
VkBool32 storagePushConstant16;
VkBool32 storageInputOutput16;
};
-typedef VkPhysicalDevice16BitStorageFeatures VkPhysicalDevice16BitStorageFeaturesKHR;
struct VkMemoryDedicatedRequirements
{
VkBool32 prefersDedicatedAllocation;
VkBool32 requiresDedicatedAllocation;
};
-typedef VkMemoryDedicatedRequirements VkMemoryDedicatedRequirementsKHR;
struct VkMemoryDedicatedAllocateInfo
{
VkImage image;
VkBuffer buffer;
};
-typedef VkMemoryDedicatedAllocateInfo VkMemoryDedicatedAllocateInfoKHR;
struct VkMemoryAllocateFlagsInfo
{
VkMemoryAllocateFlags flags;
deUint32 deviceMask;
};
-typedef VkMemoryAllocateFlagsInfo VkMemoryAllocateFlagsInfoKHR;
struct VkDeviceGroupRenderPassBeginInfo
{
deUint32 deviceRenderAreaCount;
const VkRect2D* pDeviceRenderAreas;
};
-typedef VkDeviceGroupRenderPassBeginInfo VkDeviceGroupRenderPassBeginInfoKHR;
struct VkDeviceGroupCommandBufferBeginInfo
{
const void* pNext;
deUint32 deviceMask;
};
-typedef VkDeviceGroupCommandBufferBeginInfo VkDeviceGroupCommandBufferBeginInfoKHR;
struct VkDeviceGroupSubmitInfo
{
deUint32 signalSemaphoreCount;
const deUint32* pSignalSemaphoreDeviceIndices;
};
-typedef VkDeviceGroupSubmitInfo VkDeviceGroupSubmitInfoKHR;
struct VkDeviceGroupBindSparseInfo
{
deUint32 resourceDeviceIndex;
deUint32 memoryDeviceIndex;
};
-typedef VkDeviceGroupBindSparseInfo VkDeviceGroupBindSparseInfoKHR;
struct VkBindBufferMemoryDeviceGroupInfo
{
deUint32 deviceIndexCount;
const deUint32* pDeviceIndices;
};
-typedef VkBindBufferMemoryDeviceGroupInfo VkBindBufferMemoryDeviceGroupInfoKHR;
struct VkBindImageMemoryDeviceGroupInfo
{
deUint32 SFRRectCount;
const VkRect2D* pSFRRects;
};
-typedef VkBindImageMemoryDeviceGroupInfo VkBindImageMemoryDeviceGroupInfoKHR;
struct VkPhysicalDeviceGroupProperties
{
VkPhysicalDevice physicalDevices[VK_MAX_DEVICE_GROUP_SIZE];
VkBool32 subsetAllocation;
};
-typedef VkPhysicalDeviceGroupProperties VkPhysicalDeviceGroupPropertiesKHR;
struct VkDeviceGroupDeviceCreateInfo
{
deUint32 physicalDeviceCount;
const VkPhysicalDevice* pPhysicalDevices;
};
-typedef VkDeviceGroupDeviceCreateInfo VkDeviceGroupDeviceCreateInfoKHR;
struct VkBufferMemoryRequirementsInfo2
{
const void* pNext;
VkBuffer buffer;
};
-typedef VkBufferMemoryRequirementsInfo2 VkBufferMemoryRequirementsInfo2KHR;
struct VkImageMemoryRequirementsInfo2
{
const void* pNext;
VkImage image;
};
-typedef VkImageMemoryRequirementsInfo2 VkImageMemoryRequirementsInfo2KHR;
struct VkImageSparseMemoryRequirementsInfo2
{
const void* pNext;
VkImage image;
};
-typedef VkImageSparseMemoryRequirementsInfo2 VkImageSparseMemoryRequirementsInfo2KHR;
struct VkMemoryRequirements2
{
void* pNext;
VkMemoryRequirements memoryRequirements;
};
-typedef VkMemoryRequirements2 VkMemoryRequirements2KHR;
struct VkSparseImageMemoryRequirements2
{
void* pNext;
VkSparseImageMemoryRequirements memoryRequirements;
};
-typedef VkSparseImageMemoryRequirements2 VkSparseImageMemoryRequirements2KHR;
struct VkPhysicalDeviceFeatures2
{
void* pNext;
VkPhysicalDeviceFeatures features;
};
-typedef VkPhysicalDeviceFeatures2 VkPhysicalDeviceFeatures2KHR;
struct VkPhysicalDeviceProperties2
{
void* pNext;
VkPhysicalDeviceProperties properties;
};
-typedef VkPhysicalDeviceProperties2 VkPhysicalDeviceProperties2KHR;
struct VkFormatProperties2
{
void* pNext;
VkFormatProperties formatProperties;
};
-typedef VkFormatProperties2 VkFormatProperties2KHR;
struct VkImageFormatProperties2
{
void* pNext;
VkImageFormatProperties imageFormatProperties;
};
-typedef VkImageFormatProperties2 VkImageFormatProperties2KHR;
struct VkPhysicalDeviceImageFormatInfo2
{
VkImageUsageFlags usage;
VkImageCreateFlags flags;
};
-typedef VkPhysicalDeviceImageFormatInfo2 VkPhysicalDeviceImageFormatInfo2KHR;
struct VkQueueFamilyProperties2
{
void* pNext;
VkQueueFamilyProperties queueFamilyProperties;
};
-typedef VkQueueFamilyProperties2 VkQueueFamilyProperties2KHR;
struct VkPhysicalDeviceMemoryProperties2
{
void* pNext;
VkPhysicalDeviceMemoryProperties memoryProperties;
};
-typedef VkPhysicalDeviceMemoryProperties2 VkPhysicalDeviceMemoryProperties2KHR;
struct VkSparseImageFormatProperties2
{
void* pNext;
VkSparseImageFormatProperties properties;
};
-typedef VkSparseImageFormatProperties2 VkSparseImageFormatProperties2KHR;
struct VkPhysicalDeviceSparseImageFormatInfo2
{
VkImageUsageFlags usage;
VkImageTiling tiling;
};
-typedef VkPhysicalDeviceSparseImageFormatInfo2 VkPhysicalDeviceSparseImageFormatInfo2KHR;
struct VkPhysicalDevicePointClippingProperties
{
void* pNext;
VkPointClippingBehavior pointClippingBehavior;
};
-typedef VkPhysicalDevicePointClippingProperties VkPhysicalDevicePointClippingPropertiesKHR;
struct VkInputAttachmentAspectReference
{
deUint32 inputAttachmentIndex;
VkImageAspectFlags aspectMask;
};
-typedef VkInputAttachmentAspectReference VkInputAttachmentAspectReferenceKHR;
struct VkRenderPassInputAttachmentAspectCreateInfo
{
deUint32 aspectReferenceCount;
const VkInputAttachmentAspectReference* pAspectReferences;
};
-typedef VkRenderPassInputAttachmentAspectCreateInfo VkRenderPassInputAttachmentAspectCreateInfoKHR;
struct VkImageViewUsageCreateInfo
{
const void* pNext;
VkImageUsageFlags usage;
};
-typedef VkImageViewUsageCreateInfo VkImageViewUsageCreateInfoKHR;
struct VkPipelineTessellationDomainOriginStateCreateInfo
{
const void* pNext;
VkTessellationDomainOrigin domainOrigin;
};
-typedef VkPipelineTessellationDomainOriginStateCreateInfo VkPipelineTessellationDomainOriginStateCreateInfoKHR;
struct VkRenderPassMultiviewCreateInfo
{
deUint32 correlationMaskCount;
const deUint32* pCorrelationMasks;
};
-typedef VkRenderPassMultiviewCreateInfo VkRenderPassMultiviewCreateInfoKHR;
struct VkPhysicalDeviceMultiviewFeatures
{
VkBool32 multiviewGeometryShader;
VkBool32 multiviewTessellationShader;
};
-typedef VkPhysicalDeviceMultiviewFeatures VkPhysicalDeviceMultiviewFeaturesKHR;
struct VkPhysicalDeviceMultiviewProperties
{
deUint32 maxMultiviewViewCount;
deUint32 maxMultiviewInstanceIndex;
};
-typedef VkPhysicalDeviceMultiviewProperties VkPhysicalDeviceMultiviewPropertiesKHR;
struct VkPhysicalDeviceVariablePointerFeatures
{
VkBool32 variablePointersStorageBuffer;
VkBool32 variablePointers;
};
-typedef VkPhysicalDeviceVariablePointerFeatures VkPhysicalDeviceVariablePointerFeaturesKHR;
struct VkPhysicalDeviceProtectedMemoryFeatures
{
void* pNext;
VkBool32 protectedMemory;
};
-typedef VkPhysicalDeviceProtectedMemoryFeatures VkPhysicalDeviceProtectedMemoryFeaturesKHR;
struct VkPhysicalDeviceProtectedMemoryProperties
{
void* pNext;
VkBool32 protectedNoFault;
};
-typedef VkPhysicalDeviceProtectedMemoryProperties VkPhysicalDeviceProtectedMemoryPropertiesKHR;
struct VkDeviceQueueInfo2
{
deUint32 queueFamilyIndex;
deUint32 queueIndex;
};
-typedef VkDeviceQueueInfo2 VkDeviceQueueInfo2KHR;
struct VkSamplerYcbcrConversionCreateInfo
{
VkFilter chromaFilter;
VkBool32 forceExplicitReconstruction;
};
-typedef VkSamplerYcbcrConversionCreateInfo VkSamplerYcbcrConversionCreateInfoKHR;
struct VkSamplerYcbcrConversionInfo
{
const void* pNext;
VkSamplerYcbcrConversion conversion;
};
-typedef VkSamplerYcbcrConversionInfo VkSamplerYcbcrConversionInfoKHR;
struct VkBindImagePlaneMemoryInfo
{
const void* pNext;
VkImageAspectFlagBits planeAspect;
};
-typedef VkBindImagePlaneMemoryInfo VkBindImagePlaneMemoryInfoKHR;
struct VkImagePlaneMemoryRequirementsInfo
{
const void* pNext;
VkImageAspectFlagBits planeAspect;
};
-typedef VkImagePlaneMemoryRequirementsInfo VkImagePlaneMemoryRequirementsInfoKHR;
struct VkPhysicalDeviceSamplerYcbcrConversionFeatures
{
void* pNext;
VkBool32 samplerYcbcrConversion;
};
-typedef VkPhysicalDeviceSamplerYcbcrConversionFeatures VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR;
struct VkSamplerYcbcrConversionImageFormatProperties
{
void* pNext;
deUint32 combinedImageSamplerDescriptorCount;
};
-typedef VkSamplerYcbcrConversionImageFormatProperties VkSamplerYcbcrConversionImageFormatPropertiesKHR;
struct VkDescriptorUpdateTemplateEntry
{
deUintptr offset;
deUintptr stride;
};
-typedef VkDescriptorUpdateTemplateEntry VkDescriptorUpdateTemplateEntryKHR;
struct VkDescriptorUpdateTemplateCreateInfo
{
VkPipelineLayout pipelineLayout;
deUint32 set;
};
-typedef VkDescriptorUpdateTemplateCreateInfo VkDescriptorUpdateTemplateCreateInfoKHR;
struct VkExternalMemoryProperties
{
VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes;
VkExternalMemoryHandleTypeFlags compatibleHandleTypes;
};
-typedef VkExternalMemoryProperties VkExternalMemoryPropertiesKHR;
struct VkPhysicalDeviceExternalImageFormatInfo
{
const void* pNext;
VkExternalMemoryHandleTypeFlagBits handleType;
};
-typedef VkPhysicalDeviceExternalImageFormatInfo VkPhysicalDeviceExternalImageFormatInfoKHR;
struct VkExternalImageFormatProperties
{
void* pNext;
VkExternalMemoryProperties externalMemoryProperties;
};
-typedef VkExternalImageFormatProperties VkExternalImageFormatPropertiesKHR;
struct VkPhysicalDeviceExternalBufferInfo
{
VkBufferUsageFlags usage;
VkExternalMemoryHandleTypeFlagBits handleType;
};
-typedef VkPhysicalDeviceExternalBufferInfo VkPhysicalDeviceExternalBufferInfoKHR;
struct VkExternalBufferProperties
{
void* pNext;
VkExternalMemoryProperties externalMemoryProperties;
};
-typedef VkExternalBufferProperties VkExternalBufferPropertiesKHR;
struct VkPhysicalDeviceIDProperties
{
deUint32 deviceNodeMask;
VkBool32 deviceLUIDValid;
};
-typedef VkPhysicalDeviceIDProperties VkPhysicalDeviceIDPropertiesKHR;
struct VkExternalMemoryImageCreateInfo
{
const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes;
};
-typedef VkExternalMemoryImageCreateInfo VkExternalMemoryImageCreateInfoKHR;
struct VkExternalMemoryBufferCreateInfo
{
const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes;
};
-typedef VkExternalMemoryBufferCreateInfo VkExternalMemoryBufferCreateInfoKHR;
struct VkExportMemoryAllocateInfo
{
const void* pNext;
VkExternalMemoryHandleTypeFlags handleTypes;
};
-typedef VkExportMemoryAllocateInfo VkExportMemoryAllocateInfoKHR;
struct VkPhysicalDeviceExternalFenceInfo
{
const void* pNext;
VkExternalFenceHandleTypeFlagBits handleType;
};
-typedef VkPhysicalDeviceExternalFenceInfo VkPhysicalDeviceExternalFenceInfoKHR;
struct VkExternalFenceProperties
{
VkExternalFenceHandleTypeFlags compatibleHandleTypes;
VkExternalFenceFeatureFlags externalFenceFeatures;
};
-typedef VkExternalFenceProperties VkExternalFencePropertiesKHR;
struct VkExportFenceCreateInfo
{
const void* pNext;
VkExternalFenceHandleTypeFlags handleTypes;
};
-typedef VkExportFenceCreateInfo VkExportFenceCreateInfoKHR;
struct VkExportSemaphoreCreateInfo
{
const void* pNext;
VkExternalSemaphoreHandleTypeFlags handleTypes;
};
-typedef VkExportSemaphoreCreateInfo VkExportSemaphoreCreateInfoKHR;
struct VkPhysicalDeviceExternalSemaphoreInfo
{
const void* pNext;
VkExternalSemaphoreHandleTypeFlagBits handleType;
};
-typedef VkPhysicalDeviceExternalSemaphoreInfo VkPhysicalDeviceExternalSemaphoreInfoKHR;
struct VkExternalSemaphoreProperties
{
VkExternalSemaphoreHandleTypeFlags compatibleHandleTypes;
VkExternalSemaphoreFeatureFlags externalSemaphoreFeatures;
};
-typedef VkExternalSemaphoreProperties VkExternalSemaphorePropertiesKHR;
struct VkPhysicalDeviceMaintenance3Properties
{
deUint32 maxPerSetDescriptors;
VkDeviceSize maxMemoryAllocationSize;
};
-typedef VkPhysicalDeviceMaintenance3Properties VkPhysicalDeviceMaintenance3PropertiesKHR;
struct VkDescriptorSetLayoutSupport
{
void* pNext;
VkBool32 supported;
};
-typedef VkDescriptorSetLayoutSupport VkDescriptorSetLayoutSupportKHR;
struct VkPhysicalDeviceShaderDrawParametersFeatures
{
struct VkAndroidHardwareBufferExternalFormatPropertiesANDROID
{
- VkStructureType sType;
- void* pNext;
- deUint32 externalFormat;
- VkFormatFeatureFlags formatFeatures;
- VkSamplerYcbcrModelConversionKHR suggestedYcbcrModel;
- VkSamplerYcbcrRangeKHR suggestedYcbcrRange;
- VkChromaLocationKHR suggestedXChromaOffset;
- VkChromaLocationKHR suggestedYChromaOffset;
+ VkStructureType sType;
+ void* pNext;
+ deUint32 externalFormat;
+ VkFormatFeatureFlags formatFeatures;
+ VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+ VkSamplerYcbcrRange suggestedYcbcrRange;
+ VkChromaLocation suggestedXChromaOffset;
+ VkChromaLocation suggestedYChromaOffset;
};
struct VkExternalFormatANDROID
res.y = y;
return res;
}
-
-inline VkInputAttachmentAspectReferenceKHR makeInputAttachmentAspectReferenceKHR (deUint32 subpass, deUint32 inputAttachmentIndex, VkImageAspectFlags aspectMask)
-{
- VkInputAttachmentAspectReferenceKHR res;
- res.subpass = subpass;
- res.inputAttachmentIndex = inputAttachmentIndex;
- res.aspectMask = aspectMask;
- return res;
-}
-
-inline VkDescriptorUpdateTemplateEntryKHR makeDescriptorUpdateTemplateEntryKHR (deUint32 dstBinding, deUint32 dstArrayElement, deUint32 descriptorCount, VkDescriptorType descriptorType, deUintptr offset, deUintptr stride)
-{
- VkDescriptorUpdateTemplateEntryKHR res;
- res.dstBinding = dstBinding;
- res.dstArrayElement = dstArrayElement;
- res.descriptorCount = descriptorCount;
- res.descriptorType = descriptorType;
- res.offset = offset;
- res.stride = stride;
- return res;
-}
-
-inline VkExternalMemoryPropertiesKHR makeExternalMemoryPropertiesKHR (VkExternalMemoryFeatureFlags externalMemoryFeatures, VkExternalMemoryHandleTypeFlags exportFromImportedHandleTypes, VkExternalMemoryHandleTypeFlags compatibleHandleTypes)
-{
- VkExternalMemoryPropertiesKHR res;
- res.externalMemoryFeatures = externalMemoryFeatures;
- res.exportFromImportedHandleTypes = exportFromImportedHandleTypes;
- res.compatibleHandleTypes = compatibleHandleTypes;
- return res;
-}
virtual VkResult queuePresentKHR (VkQueue queue, const VkPresentInfoKHR* pPresentInfo) const = 0;
virtual VkResult acquireNextImage2KHR (VkDevice device, const VkAcquireNextImageInfoKHR* pAcquireInfo, deUint32* pImageIndex) const = 0;
virtual VkResult createSharedSwapchainsKHR (VkDevice device, deUint32 swapchainCount, const VkSwapchainCreateInfoKHR* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchains) const = 0;
-virtual void getDeviceGroupPeerMemoryFeaturesKHR (VkDevice device, deUint32 heapIndex, deUint32 localDeviceIndex, deUint32 remoteDeviceIndex, VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) const = 0;
-virtual void cmdSetDeviceMaskKHR (VkCommandBuffer commandBuffer, deUint32 deviceMask) const = 0;
-virtual void cmdDispatchBaseKHR (VkCommandBuffer commandBuffer, deUint32 baseGroupX, deUint32 baseGroupY, deUint32 baseGroupZ, deUint32 groupCountX, deUint32 groupCountY, deUint32 groupCountZ) const = 0;
-virtual void trimCommandPoolKHR (VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlags flags) const = 0;
virtual VkResult getMemoryWin32HandleKHR (VkDevice device, const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const = 0;
virtual VkResult getMemoryWin32HandlePropertiesKHR (VkDevice device, VkExternalMemoryHandleTypeFlagBits handleType, pt::Win32Handle handle, VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) const = 0;
virtual VkResult getMemoryFdKHR (VkDevice device, const VkMemoryGetFdInfoKHR* pGetFdInfo, int* pFd) const = 0;
virtual VkResult getSemaphoreFdKHR (VkDevice device, const VkSemaphoreGetFdInfoKHR* pGetFdInfo, int* pFd) const = 0;
virtual void cmdPushDescriptorSetKHR (VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, deUint32 set, deUint32 descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites) const = 0;
virtual void cmdPushDescriptorSetWithTemplateKHR (VkCommandBuffer commandBuffer, VkDescriptorUpdateTemplate descriptorUpdateTemplate, VkPipelineLayout layout, deUint32 set, const void* pData) const = 0;
-virtual VkResult createDescriptorUpdateTemplateKHR (VkDevice device, const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) const = 0;
-virtual void destroyDescriptorUpdateTemplateKHR (VkDevice device, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const VkAllocationCallbacks* pAllocator) const = 0;
-virtual void updateDescriptorSetWithTemplateKHR (VkDevice device, VkDescriptorSet descriptorSet, VkDescriptorUpdateTemplate descriptorUpdateTemplate, const void* pData) const = 0;
virtual VkResult getSwapchainStatusKHR (VkDevice device, VkSwapchainKHR swapchain) const = 0;
virtual VkResult importFenceWin32HandleKHR (VkDevice device, const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) const = 0;
virtual VkResult getFenceWin32HandleKHR (VkDevice device, const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, pt::Win32Handle* pHandle) const = 0;
virtual VkResult importFenceFdKHR (VkDevice device, const VkImportFenceFdInfoKHR* pImportFenceFdInfo) const = 0;
virtual VkResult getFenceFdKHR (VkDevice device, const VkFenceGetFdInfoKHR* pGetFdInfo, int* pFd) const = 0;
-virtual void getDeviceQueue2KHR (VkDevice device, const VkDeviceQueueInfo2* pQueueInfo, VkQueue* pQueue) const = 0;
-virtual void getImageMemoryRequirements2KHR (VkDevice device, const VkImageMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const = 0;
-virtual void getBufferMemoryRequirements2KHR (VkDevice device, const VkBufferMemoryRequirementsInfo2* pInfo, VkMemoryRequirements2* pMemoryRequirements) const = 0;
-virtual void getImageSparseMemoryRequirements2KHR (VkDevice device, const VkImageSparseMemoryRequirementsInfo2* pInfo, deUint32* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) const = 0;
-virtual VkResult createSamplerYcbcrConversionKHR (VkDevice device, const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSamplerYcbcrConversion* pYcbcrConversion) const = 0;
-virtual void destroySamplerYcbcrConversionKHR (VkDevice device, VkSamplerYcbcrConversion ycbcrConversion, const VkAllocationCallbacks* pAllocator) const = 0;
-virtual VkResult bindBufferMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindBufferMemoryInfo* pBindInfos) const = 0;
-virtual VkResult bindImageMemory2KHR (VkDevice device, deUint32 bindInfoCount, const VkBindImageMemoryInfo* pBindInfos) const = 0;
-virtual void getDescriptorSetLayoutSupportKHR (VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayoutSupport* pSupport) const = 0;
virtual VkResult debugMarkerSetObjectTagEXT (VkDevice device, const VkDebugMarkerObjectTagInfoEXT* pTagInfo) const = 0;
virtual VkResult debugMarkerSetObjectNameEXT (VkDevice device, const VkDebugMarkerObjectNameInfoEXT* pNameInfo) const = 0;
virtual void cmdDebugMarkerBeginEXT (VkCommandBuffer commandBuffer, const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) const = 0;
virtual VkResult createAndroidSurfaceKHR (VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const = 0;
virtual VkResult createWin32SurfaceKHR (VkInstance instance, const VkWin32SurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) const = 0;
virtual VkBool32 getPhysicalDeviceWin32PresentationSupportKHR (VkPhysicalDevice physicalDevice, deUint32 queueFamilyIndex) const = 0;
-virtual void getPhysicalDeviceFeatures2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures2* pFeatures) const = 0;
-virtual void getPhysicalDeviceProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties2* pProperties) const = 0;
-virtual void getPhysicalDeviceFormatProperties2KHR (VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties2* pFormatProperties) const = 0;
-virtual VkResult getPhysicalDeviceImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, VkImageFormatProperties2* pImageFormatProperties) const = 0;
-virtual void getPhysicalDeviceQueueFamilyProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pQueueFamilyPropertyCount, VkQueueFamilyProperties2* pQueueFamilyProperties) const = 0;
-virtual void getPhysicalDeviceMemoryProperties2KHR (VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2* pMemoryProperties) const = 0;
-virtual void getPhysicalDeviceSparseImageFormatProperties2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, deUint32* pPropertyCount, VkSparseImageFormatProperties2* pProperties) const = 0;
-virtual VkResult enumeratePhysicalDeviceGroupsKHR (VkInstance instance, deUint32* pPhysicalDeviceGroupCount, VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) const = 0;
-virtual void getPhysicalDeviceExternalBufferPropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, VkExternalBufferProperties* pExternalBufferProperties) const = 0;
-virtual void getPhysicalDeviceExternalSemaphorePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, VkExternalSemaphoreProperties* pExternalSemaphoreProperties) const = 0;
-virtual void getPhysicalDeviceExternalFencePropertiesKHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, VkExternalFenceProperties* pExternalFenceProperties) const = 0;
virtual VkResult getPhysicalDeviceSurfaceCapabilities2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, VkSurfaceCapabilities2KHR* pSurfaceCapabilities) const = 0;
virtual VkResult getPhysicalDeviceSurfaceFormats2KHR (VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, deUint32* pSurfaceFormatCount, VkSurfaceFormat2KHR* pSurfaceFormats) const = 0;
virtual VkResult getPhysicalDeviceDisplayProperties2KHR (VkPhysicalDevice physicalDevice, deUint32* pPropertyCount, VkDisplayProperties2KHR* pProperties) const = 0;
memoryProperties = getPhysicalDeviceMemoryProperties(vkInstance, vkPhysicalDevice);
const VkPhysicalDeviceLimits limits = getPhysicalDeviceProperties(vkInstance, vkPhysicalDevice).limits;
- VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType;
DE_NULL, // const void* pNext;
false, // VkBool32 prefersDedicatedAllocation
false // VkBool32 requiresDedicatedAllocation
};
- VkMemoryRequirements2KHR memReqs =
+ VkMemoryRequirements2 memReqs =
{
- VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, // VkStructureType sType
+ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
&dedicatedRequirements, // void* pNext
{0, 0, 0} // VkMemoryRequirements memoryRequirements
};
Move<VkBuffer> buffer = createBuffer(vk, vkDevice, &bufferParams);
- VkBufferMemoryRequirementsInfo2KHR info =
+ VkBufferMemoryRequirementsInfo2 info =
{
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, // VkStructureType sType
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
DE_NULL, // const void* pNext
*buffer // VkBuffer buffer
};
- vk.getBufferMemoryRequirements2KHR(vkDevice, &info, &memReqs);
+ vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs);
if (dedicatedRequirements.requiresDedicatedAllocation == VK_TRUE)
{
}
info.buffer = *buffer;
- vk.getBufferMemoryRequirements2KHR(vkDevice, &info, &memReqs); // get the proper size requirement
+ vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs); // get the proper size requirement
if (size > memReqs.memoryRequirements.size)
{
VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
VkDeviceMemory rawMemory = DE_NULL;
- vk::VkMemoryDedicatedAllocateInfoKHR
+ vk::VkMemoryDedicatedAllocateInfo
dedicatedInfo =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, // VkStructureType sType
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
DE_NULL, // VkImage image
*buffer // VkBuffer buffer
const DeviceInterface& vk = context.getDeviceInterface();
const deUint32 queueFamilyIndex = context.getUniversalQueueFamilyIndex();
VkPhysicalDeviceMemoryProperties memoryProperties;
- VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, // VkStructureType sType;
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType;
DE_NULL, // const void* pNext;
false, // VkBool32 prefersDedicatedAllocation
false // VkBool32 requiresDedicatedAllocation
};
- VkMemoryRequirements2KHR memReqs =
+ VkMemoryRequirements2 memReqs =
{
- VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, // VkStructureType sType
+ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
&dedicatedRequirements, // void* pNext
{0, 0, 0} // VkMemoryRequirements memoryRequirements
};
return tcu::TestStatus::fail("Buffer creation failed! (Error code: " + de::toString(error.getMessage()) + ")");
}
- VkBufferMemoryRequirementsInfo2KHR info =
+ VkBufferMemoryRequirementsInfo2 info =
{
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, // VkStructureType sType
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
DE_NULL, // const void* pNext
*testBuffer // VkBuffer buffer
};
- vk.getBufferMemoryRequirements2KHR(vkDevice, &info, &memReqs);
+ vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs);
if (dedicatedRequirements.requiresDedicatedAllocation == VK_TRUE)
{
//const VkMemoryType memoryType = memoryProperties.memoryTypes[heapTypeIndex];
//const VkMemoryHeap memoryHeap = memoryProperties.memoryHeaps[memoryType.heapIndex];
- vk.getBufferMemoryRequirements2KHR(vkDevice, &info, &memReqs); // get the proper size requirement
+ vk.getBufferMemoryRequirements2(vkDevice, &info, &memReqs); // get the proper size requirement
if (size > memReqs.memoryRequirements.size)
{
VkResult result = VK_ERROR_OUT_OF_HOST_MEMORY;
VkDeviceMemory rawMemory = DE_NULL;
- vk::VkMemoryDedicatedAllocateInfoKHR
+ vk::VkMemoryDedicatedAllocateInfo
dedicatedInfo =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, // VkStructureType sType
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO, // VkStructureType sType
DE_NULL, // const void* pNext
DE_NULL, // VkImage image
*testBuffer // VkBuffer buffer
vk.freeCommandBuffers(vkDevice, *cmdPool, static_cast<deUint32>(cmdBuffersPeak.size()), &cmdBuffersPeak[0]);
}
- vk.trimCommandPoolKHR(vkDevice, *cmdPool, (VkCommandPoolTrimFlagsKHR)0);
+ vk.trimCommandPool(vkDevice, *cmdPool, (VkCommandPoolTrimFlags)0);
switch(cmdBufferLevel)
{
{
++numErrorsReturned;
- if (expectOutOfPoolMemoryError && result != VK_ERROR_OUT_OF_POOL_MEMORY_KHR)
- return tcu::TestStatus::fail("Expected VK_ERROR_OUT_OF_POOL_MEMORY_KHR but got " + string(getResultName(result)) + " instead");
+ if (expectOutOfPoolMemoryError && result != VK_ERROR_OUT_OF_POOL_MEMORY)
+ return tcu::TestStatus::fail("Expected VK_ERROR_OUT_OF_POOL_MEMORY but got " + string(getResultName(result)) + " instead");
}
else
context.getTestContext().getLog() << tcu::TestLog::Message << " Allocation was successful anyway" << tcu::TestLog::EndMessage;
const deUint32 queueIndex = 0;
const float queuePriority = 1.0f;
- VkPhysicalDeviceFeatures2KHR enabledFeatures;
+ VkPhysicalDeviceFeatures2 enabledFeatures;
const VkDeviceQueueCreateInfo deviceQueueCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_QUEUE_CREATE_INFO,
};
// Populate enabledFeatures
- enabledFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ enabledFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
enabledFeatures.pNext = DE_NULL;
- vki.getPhysicalDeviceFeatures2KHR(physicalDevice, &enabledFeatures);
+ vki.getPhysicalDeviceFeatures2(physicalDevice, &enabledFeatures);
{
const Unique<VkDevice> device (createDevice(vki, physicalDevice, &deviceCreateInfo));
namespace
{
-vk::VkMemoryDedicatedRequirementsKHR getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkBuffer buffer)
+vk::VkMemoryDedicatedRequirements getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkBuffer buffer)
{
- const vk::VkBufferMemoryRequirementsInfo2KHR requirementInfo =
+ const vk::VkBufferMemoryRequirementsInfo2 requirementInfo =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
buffer
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u }
};
- vkd.getBufferMemoryRequirements2KHR(device, &requirementInfo, &requirements);
+ vkd.getBufferMemoryRequirements2(device, &requirementInfo, &requirements);
return dedicatedRequirements;
}
-vk::VkMemoryDedicatedRequirementsKHR getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkImage image)
+vk::VkMemoryDedicatedRequirements getMemoryDedicatedRequirements (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkImage image)
{
- const vk::VkImageMemoryRequirementsInfo2KHR requirementInfo =
+ const vk::VkImageMemoryRequirementsInfo2 requirementInfo =
{
- vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
image
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u }
};
- vkd.getImageMemoryRequirements2KHR(device, &requirementInfo, &requirements);
+ vkd.getImageMemoryRequirements2(device, &requirementInfo, &requirements);
return dedicatedRequirements;
}
TCU_THROW(NotSupportedError, "Queue type not supported");
}
-std::vector<std::string> getInstanceExtensions (const vk::VkExternalSemaphoreHandleTypeFlagsKHR externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlagsKHR externalMemoryTypes,
- const vk::VkExternalFenceHandleTypeFlagsKHR externalFenceTypes)
+std::vector<std::string> getInstanceExtensions (const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
{
std::vector<std::string> instanceExtensions;
}
vk::Move<vk::VkInstance> createInstance (const vk::PlatformInterface& vkp,
- const vk::VkExternalSemaphoreHandleTypeFlagsKHR externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlagsKHR externalMemoryTypes,
- const vk::VkExternalFenceHandleTypeFlagsKHR externalFenceTypes)
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes)
{
try
{
vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice physicalDevice,
- const vk::VkExternalSemaphoreHandleTypeFlagsKHR externalSemaphoreTypes,
- const vk::VkExternalMemoryHandleTypeFlagsKHR externalMemoryTypes,
- const vk::VkExternalFenceHandleTypeFlagsKHR externalFenceTypes,
+ const vk::VkExternalSemaphoreHandleTypeFlags externalSemaphoreTypes,
+ const vk::VkExternalMemoryHandleTypeFlags externalMemoryTypes,
+ const vk::VkExternalFenceHandleTypeFlags externalFenceTypes,
deUint32 queueFamilyIndex,
bool useDedicatedAllocs = false)
{
std::vector<const char*> deviceExtensions;
if ((externalSemaphoreTypes
- & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_semaphore_fd");
}
if ((externalFenceTypes
- & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_fence_fd");
}
}
if ((externalMemoryTypes
- & vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR) != 0)
+ & vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT) != 0)
{
deviceExtensions.push_back("VK_KHR_external_memory_fd");
}
if ((externalSemaphoreTypes
- & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ | vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_semaphore_win32");
}
if ((externalFenceTypes
- & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ | vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_fence_win32");
}
if ((externalMemoryTypes
- & (vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR
- | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR)) != 0)
+ & (vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT
+ | vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT)) != 0)
{
deviceExtensions.push_back("VK_KHR_external_memory_win32");
}
void checkSemaphoreSupport (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice device,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
- const vk::VkPhysicalDeviceExternalSemaphoreInfoKHR info =
+ const vk::VkPhysicalDeviceExternalSemaphoreInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalSemaphorePropertiesKHR properties =
+ vk::VkExternalSemaphoreProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalSemaphorePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalSemaphoreProperties(device, &info, &properties);
- if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Semaphore doesn't support exporting in external type");
- if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Semaphore doesn't support importing in external type");
}
void checkFenceSupport (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice device,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalFenceHandleTypeFlagBits externalType)
{
- const vk::VkPhysicalDeviceExternalFenceInfoKHR info =
+ const vk::VkPhysicalDeviceExternalFenceInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalFencePropertiesKHR properties =
+ vk::VkExternalFenceProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalFencePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalFenceProperties(device, &info, &properties);
- if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Fence doesn't support exporting in external type");
- if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalFenceFeatures & vk::VK_EXTERNAL_FENCE_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Fence doesn't support importing in external type");
}
void checkBufferSupport (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice device,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkBufferViewCreateFlags createFlag,
vk::VkBufferUsageFlags usageFlag,
bool dedicated)
{
- const vk::VkPhysicalDeviceExternalBufferInfoKHR info =
+ const vk::VkPhysicalDeviceExternalBufferInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
DE_NULL,
createFlag,
usageFlag,
externalType
};
- vk::VkExternalBufferPropertiesKHR properties =
+ vk::VkExternalBufferProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
- vki.getPhysicalDeviceExternalBufferPropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalBufferProperties(device, &info, &properties);
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support exporting buffer");
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support importing buffer");
- if (!dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ if (!dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0)
TCU_THROW(NotSupportedError, "External handle type requires dedicated allocation");
}
void checkImageSupport (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice device,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkImageViewCreateFlags createFlag,
vk::VkImageUsageFlags usageFlag,
vk::VkFormat format,
vk::VkImageTiling tiling,
bool dedicated)
{
- const vk::VkPhysicalDeviceExternalImageFormatInfoKHR externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
externalType
};
- const vk::VkPhysicalDeviceImageFormatInfo2KHR info =
+ const vk::VkPhysicalDeviceImageFormatInfo2 info =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
&externalInfo,
usageFlag,
createFlag,
};
- vk::VkExternalImageFormatPropertiesKHR externalProperties =
+ vk::VkExternalImageFormatProperties externalProperties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
- vk::VkImageFormatProperties2KHR properties =
+ vk::VkImageFormatProperties2 properties =
{
vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
&externalProperties,
}
};
- vki.getPhysicalDeviceImageFormatProperties2KHR(device, &info, &properties);
+ vki.getPhysicalDeviceImageFormatProperties2(device, &info, &properties);
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support exporting image");
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "External handle type doesn't support importing image");
- if (!dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ if (!dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0)
TCU_THROW(NotSupportedError, "External handle type requires dedicated allocation");
}
VK_CHECK(vkd.queueSubmit(queue, 1, &submit, fence));
}
-tcu::TestStatus testSemaphoreQueries (Context& context, vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testSemaphoreQueries (Context& context, vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
const vk::Unique<vk::VkInstance> instance (createInstance(vkp, externalType, 0u, 0u));
TestLog& log = context.getTestContext().getLog();
- const vk::VkPhysicalDeviceExternalSemaphoreInfoKHR info =
+ const vk::VkPhysicalDeviceExternalSemaphoreInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalSemaphorePropertiesKHR properties =
+ vk::VkExternalSemaphoreProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalSemaphorePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalSemaphoreProperties(device, &info, &properties);
log << TestLog::Message << properties << TestLog::EndMessage;
TCU_CHECK(properties.pNext == DE_NULL);
- TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES_KHR);
+ TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_SEMAPHORE_PROPERTIES);
return tcu::TestStatus::pass("Pass");
}
struct SemaphoreTestConfig
{
- SemaphoreTestConfig (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType_,
+ SemaphoreTestConfig (vk::VkExternalSemaphoreHandleTypeFlagBits externalType_,
Permanence permanence_)
: externalType (externalType_)
, permanence (permanence_)
{
}
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType;
- Permanence permanence;
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType;
+ Permanence permanence;
};
tcu::TestStatus testSemaphoreWin32Create (Context& context,
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportSemaphoreCreateInfoKHR exportCreateInfo=
+ const vk::VkExportSemaphoreCreateInfo exportCreateInfo=
{
- vk::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
&win32ExportInfo,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)config.externalType
+ (vk::VkExternalMemoryHandleTypeFlags)config.externalType
};
- const vk::VkSemaphoreCreateInfo createInfo =
+ const vk::VkSemaphoreCreateInfo createInfo =
{
vk::VK_STRUCTURE_TYPE_SEMAPHORE_CREATE_INFO,
&exportCreateInfo,
getSemaphoreNative(vkd, *device, *semaphore, config.externalType, handleA);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkSemaphore> semaphoreA (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
if (transference == TRANSFERENCE_COPY)
{
NativeHandle handleB (handleA);
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkSemaphore> semaphoreA (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
const vk::Unique<vk::VkSemaphore> semaphoreB (createAndImportSemaphore(vkd, *device, config.externalType, handleB, flags));
getSemaphoreNative(vkd, *device, *semaphoreA, config.externalType, handleA);
NativeHandle handleB (handleA);
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkSemaphore> semaphoreB (createAndImportSemaphore(vkd, *device, config.externalType, handleA, flags));
importSemaphore(vkd, *device, *semaphoreB, config.externalType, handleB, flags);
getSemaphoreNative(vkd, *device, *semaphoreA, config.externalType, handle);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkSemaphore> semaphoreB (createAndImportSemaphore(vkd, *device, config.externalType, handle, flags));
submitDummyWait(vkd, queue, *semaphoreB);
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
DE_ASSERT(getHandelTypeTransferences(config.externalType) == TRANSFERENCE_REFERENCE);
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkSemaphoreSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, config.externalType, 0u, 0u, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
}
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const NativeHandle fd (getSemaphoreFd(vkd, *device, *semaphoreA, config.externalType));
NativeHandle secondFd (getSemaphoreFd(vkd, *device, *semaphoreB, config.externalType));
const int newFd (dup3(fd.getFd(), secondFd.getFd(), 0));
}
else
{
- const vk::VkSemaphoreImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkSemaphoreImportFlagBitsKHR)0u;
+ const vk::VkSemaphoreImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_SEMAPHORE_IMPORT_TEMPORARY_BIT : (vk::VkSemaphoreImportFlagBits)0u;
const cmsghdr* const cmsg = CMSG_FIRSTHDR(&msg);
int newFd_;
deMemcpy(&newFd_, CMSG_DATA(cmsg), sizeof(int));
#endif
}
-tcu::TestStatus testFenceQueries (Context& context, vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testFenceQueries (Context& context, vk::VkExternalFenceHandleTypeFlagBits externalType)
{
const vk::PlatformInterface& vkp (context.getPlatformInterface());
const vk::Unique<vk::VkInstance> instance (createInstance(vkp, 0u, 0u, externalType));
TestLog& log = context.getTestContext().getLog();
- const vk::VkPhysicalDeviceExternalFenceInfoKHR info =
+ const vk::VkPhysicalDeviceExternalFenceInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_FENCE_INFO,
DE_NULL,
externalType
};
- vk::VkExternalFencePropertiesKHR properties =
+ vk::VkExternalFenceProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES,
DE_NULL,
0u,
0u,
0u
};
- vki.getPhysicalDeviceExternalFencePropertiesKHR(device, &info, &properties);
+ vki.getPhysicalDeviceExternalFenceProperties(device, &info, &properties);
log << TestLog::Message << properties << TestLog::EndMessage;
TCU_CHECK(properties.pNext == DE_NULL);
- TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES_KHR);
+ TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_FENCE_PROPERTIES);
return tcu::TestStatus::pass("Pass");
}
struct FenceTestConfig
{
- FenceTestConfig (vk::VkExternalFenceHandleTypeFlagBitsKHR externalType_,
+ FenceTestConfig (vk::VkExternalFenceHandleTypeFlagBits externalType_,
Permanence permanence_)
: externalType (externalType_)
, permanence (permanence_)
{
}
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType;
- Permanence permanence;
+ vk::VkExternalFenceHandleTypeFlagBits externalType;
+ Permanence permanence;
};
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportFenceCreateInfoKHR exportCreateInfo=
+ const vk::VkExportFenceCreateInfo exportCreateInfo=
{
- vk::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
&win32ExportInfo,
- (vk::VkExternalFenceHandleTypeFlagsKHR)config.externalType
+ (vk::VkExternalFenceHandleTypeFlags)config.externalType
};
const vk::VkFenceCreateInfo createInfo =
{
getFenceNative(vkd, *device, *fence, config.externalType, handleA);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkFence> fenceA (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
if (transference == TRANSFERENCE_COPY)
{
NativeHandle handleB (handleA);
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkFence> fenceA (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
const vk::Unique<vk::VkFence> fenceB (createAndImportFence(vkd, *device, config.externalType, handleB, flags));
getFenceNative(vkd, *device, *fenceA, config.externalType, handleA);
NativeHandle handleB (handleA);
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkFence> fenceB (createAndImportFence(vkd, *device, config.externalType, handleA, flags));
importFence(vkd, *device, *fenceB, config.externalType, handleB, flags);
getFenceNative(vkd, *device, *fenceA, config.externalType, handle);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkFence> fenceB (createAndImportFence(vkd, *device, config.externalType, handle, flags));
VK_CHECK(vkd.waitForFences(*device, 1u, &*fenceB, VK_TRUE, ~0ull));
const vk::InstanceDriver vki (vkp, *instance);
const vk::VkPhysicalDevice physicalDevice (vk::chooseDevice(vki, *instance, context.getTestContext().getCommandLine()));
const deUint32 queueFamilyIndex (chooseQueueFamilyIndex(vki, physicalDevice, 0u));
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
DE_ASSERT(getHandelTypeTransferences(config.externalType) == TRANSFERENCE_REFERENCE);
checkFenceSupport(vki, physicalDevice, config.externalType);
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
checkFenceSupport(vki, physicalDevice, config.externalType);
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const vk::Unique<vk::VkDevice> device (createDevice(vki, physicalDevice, 0u, 0u, config.externalType, queueFamilyIndex));
const vk::DeviceDriver vkd (vki, *device);
const vk::VkQueue queue (getQueue(vkd, *device, queueFamilyIndex));
}
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const NativeHandle fd (getFenceFd(vkd, *device, *fenceA, config.externalType));
NativeHandle secondFd (getFenceFd(vkd, *device, *fenceB, config.externalType));
const int newFd (dup3(fd.getFd(), secondFd.getFd(), 0));
}
else
{
- const vk::VkFenceImportFlagsKHR flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT_KHR : (vk::VkFenceImportFlagBitsKHR)0u;
+ const vk::VkFenceImportFlags flags = config.permanence == PERMANENCE_TEMPORARY ? vk::VK_FENCE_IMPORT_TEMPORARY_BIT : (vk::VkFenceImportFlagBits)0u;
const cmsghdr* const cmsg = CMSG_FIRSTHDR(&msg);
int newFd_;
deMemcpy(&newFd_, CMSG_DATA(cmsg), sizeof(int));
#endif
}
-tcu::TestStatus testBufferQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testBufferQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
const vk::VkBufferCreateFlags createFlags[] =
{
{
const vk::VkBufferViewCreateFlags createFlag = createFlags[createFlagNdx];
const vk::VkBufferUsageFlags usageFlag = usageFlags[usageFlagNdx];
- const vk::VkPhysicalDeviceExternalBufferInfoKHR info =
+ const vk::VkPhysicalDeviceExternalBufferInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
DE_NULL,
createFlag,
usageFlag,
externalType
};
- vk::VkExternalBufferPropertiesKHR properties =
+ vk::VkExternalBufferProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
(deviceFeatures.sparseResidencyBuffer == VK_FALSE))
continue;
- vki.getPhysicalDeviceExternalBufferPropertiesKHR(physicalDevice, &info, &properties);
+ vki.getPhysicalDeviceExternalBufferProperties(physicalDevice, &info, &properties);
log << TestLog::Message << properties << TestLog::EndMessage;
- TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR);
+ TCU_CHECK(properties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES);
TCU_CHECK(properties.pNext == DE_NULL);
// \todo [2017-06-06 pyry] Can we validate anything else? Compatible types?
- if ((properties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)) != 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT)) != 0)
{
- const bool requiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const bool requiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
if (!device || (requiresDedicated && !deviceHasDedicated))
{
}
}
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) != 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) != 0)
{
DE_ASSERT(!!device);
DE_ASSERT(vkd);
if (deviceHasDedicated)
{
const vk::Unique<vk::VkBuffer> buffer (createExternalBuffer(*vkd, *device, queueFamilyIndex, externalType, 1024u, createFlag, usageFlag));
- const vk::VkMemoryDedicatedRequirementsKHR reqs (getMemoryDedicatedRequirements(*vkd, *device, *buffer));
- const bool propertiesRequiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *buffer));
+ const bool propertiesRequiresDedicated = (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
const bool objectRequiresDedicated = (reqs.requiresDedicatedAllocation != VK_FALSE);
if (propertiesRequiresDedicated != objectRequiresDedicated)
// This check should be redundant as the code above tries to create device with
// VK_KHR_dedicated_allocation & VK_KHR_get_memory_requirements2 if dedicated memory
// is required. However, checking again doesn't hurt.
- TCU_CHECK((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) == 0);
+ TCU_CHECK((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) == 0);
}
}
}
struct MemoryTestConfig
{
- MemoryTestConfig (vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType_,
+ MemoryTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
bool hostVisible_,
bool dedicated_)
: externalType (externalType_)
{
}
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType;
- bool hostVisible;
- bool dedicated;
+ vk::VkExternalMemoryHandleTypeFlagBits externalType;
+ bool hostVisible;
+ bool dedicated;
};
#if (DE_OS == DE_OS_WIN32)
DXGI_SHARED_RESOURCE_READ | DXGI_SHARED_RESOURCE_WRITE,
DE_NULL
};
- const vk::VkExportMemoryAllocateInfoKHR exportInfo =
+ const vk::VkExportMemoryAllocateInfo exportInfo =
{
- vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
&win32Info,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)config.externalType
+ (vk::VkExternalMemoryHandleTypeFlags)config.externalType
};
exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits & compatibleMemTypes);
struct BufferTestConfig
{
- BufferTestConfig (vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType_,
+ BufferTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
bool dedicated_)
: externalType (externalType_)
, dedicated (dedicated_)
{
}
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType;
- bool dedicated;
+ vk::VkExternalMemoryHandleTypeFlagBits externalType;
+ bool dedicated;
};
tcu::TestStatus testBufferBindExportImportBind (Context& context,
return tcu::TestStatus::pass("Pass");
}
-tcu::TestStatus testImageQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+tcu::TestStatus testImageQueries (Context& context, vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
const vk::VkImageCreateFlags createFlags[] =
{
vk::VK_IMAGE_CREATE_SPARSE_BINDING_BIT|vk::VK_IMAGE_CREATE_SPARSE_ALIASED_BIT,
vk::VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT,
vk::VK_IMAGE_CREATE_CUBE_COMPATIBLE_BIT,
- vk::VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT_KHR
+ vk::VK_IMAGE_CREATE_2D_ARRAY_COMPATIBLE_BIT
};
const vk::VkImageUsageFlags usageFlags[] =
{
const vk::VkFormat format = vk::VK_FORMAT_R8G8B8A8_UNORM;
const vk::VkImageType type = vk::VK_IMAGE_TYPE_2D;
const vk::VkImageTiling tiling = vk::VK_IMAGE_TILING_OPTIMAL;
- const vk::VkPhysicalDeviceExternalImageFormatInfoKHR externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
externalType
};
- const vk::VkPhysicalDeviceImageFormatInfo2KHR info =
+ const vk::VkPhysicalDeviceImageFormatInfo2 info =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
&externalInfo,
usageFlag,
createFlag,
};
- vk::VkExternalImageFormatPropertiesKHR externalProperties =
+ vk::VkExternalImageFormatProperties externalProperties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
- vk::VkImageFormatProperties2KHR properties =
+ vk::VkImageFormatProperties2 properties =
{
vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
&externalProperties,
(deviceFeatures.sparseResidencyAliased == VK_FALSE))
continue;
- vki.getPhysicalDeviceImageFormatProperties2KHR(physicalDevice, &info, &properties);
+ vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &info, &properties);
log << TestLog::Message << externalProperties << TestLog::EndMessage;
- TCU_CHECK(externalProperties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR);
+ TCU_CHECK(externalProperties.sType == vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES);
TCU_CHECK(externalProperties.pNext == DE_NULL);
// \todo [2017-06-06 pyry] Can we validate anything else? Compatible types?
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR)) != 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & (vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT|vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT)) != 0)
{
- const bool requiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const bool requiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
if (!device || (requiresDedicated && !deviceHasDedicated))
{
}
}
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) != 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) != 0)
{
DE_ASSERT(!!device);
DE_ASSERT(vkd);
if (deviceHasDedicated)
{
const vk::Unique<vk::VkImage> image (createExternalImage(*vkd, *device, queueFamilyIndex, externalType, format, 16u, 16u, tiling, createFlag, usageFlag));
- const vk::VkMemoryDedicatedRequirementsKHR reqs (getMemoryDedicatedRequirements(*vkd, *device, *image));
- const bool propertiesRequiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0;
+ const vk::VkMemoryDedicatedRequirements reqs (getMemoryDedicatedRequirements(*vkd, *device, *image));
+ const bool propertiesRequiresDedicated = (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0;
const bool objectRequiresDedicated = (reqs.requiresDedicatedAllocation != VK_FALSE);
if (propertiesRequiresDedicated != objectRequiresDedicated)
// This check should be redundant as the code above tries to create device with
// VK_KHR_dedicated_allocation & VK_KHR_get_memory_requirements2 if dedicated memory
// is required. However, checking again doesn't hurt.
- TCU_CHECK((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) == 0);
+ TCU_CHECK((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) == 0);
}
}
}
struct ImageTestConfig
{
- ImageTestConfig (vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType_,
+ ImageTestConfig (vk::VkExternalMemoryHandleTypeFlagBits externalType_,
bool dedicated_)
: externalType (externalType_)
, dedicated (dedicated_)
{
}
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType;
+ vk::VkExternalMemoryHandleTypeFlagBits externalType;
bool dedicated;
};
return tcu::TestStatus::pass("Pass");
}
-de::MovePtr<tcu::TestCaseGroup> createFenceTests (tcu::TestContext& testCtx, vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+de::MovePtr<tcu::TestCaseGroup> createFenceTests (tcu::TestContext& testCtx, vk::VkExternalFenceHandleTypeFlagBits externalType)
{
const struct
{
if (!isSupportedPermanence(externalType, permanence))
continue;
- if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
addFunctionCase(fenceGroup.get(), std::string("create_win32_") + permanenceName, "Test creating fence with win32 properties.", testFenceWin32Create, config);
}
addFunctionCase(fenceGroup.get(), std::string("reset_") + permanenceName, "Test resetting the fence.", testFenceReset, config);
addFunctionCase(fenceGroup.get(), std::string("transference_") + permanenceName, "Test fences transference.", testFenceTransference, config);
- if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
// \note Not supported on WIN32 handles
addFunctionCase(fenceGroup.get(), std::string("export_multiple_times_") + permanenceName, "Test exporting fence multiple times.", testFenceMultipleExports, config);
{
de::MovePtr<tcu::TestCaseGroup> fenceGroup (new tcu::TestCaseGroup(testCtx, "fence", "Tests for external fences."));
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR).release());
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR).release());
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR).release());
- fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT).release());
+ fenceGroup->addChild(createFenceTests(testCtx, vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT).release());
return fenceGroup;
}
-de::MovePtr<tcu::TestCaseGroup> createSemaphoreTests (tcu::TestContext& testCtx, vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+de::MovePtr<tcu::TestCaseGroup> createSemaphoreTests (tcu::TestContext& testCtx, vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
const struct
{
if (!isSupportedPermanence(externalType, permanence))
continue;
- if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
addFunctionCase(semaphoreGroup.get(), std::string("create_win32_") + permanenceName, "Test creating semaphore with win32 properties.", testSemaphoreWin32Create, config);
}
addFunctionCase(semaphoreGroup.get(), std::string("signal_import_") + permanenceName, "Test signaling and importing the semaphore.", testSemaphoreSignalImport, config);
addFunctionCase(semaphoreGroup.get(), std::string("transference_") + permanenceName, "Test semaphores transference.", testSemaphoreTransference, config);
- if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
// \note Not supported on WIN32 handles
addFunctionCase(semaphoreGroup.get(), std::string("export_multiple_times_") + permanenceName, "Test exporting semaphore multiple times.", testSemaphoreMultipleExports, config);
{
de::MovePtr<tcu::TestCaseGroup> semaphoreGroup (new tcu::TestCaseGroup(testCtx, "semaphore", "Tests for external semaphores."));
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR).release());
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR).release());
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR).release());
- semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT).release());
+ semaphoreGroup->addChild(createSemaphoreTests(testCtx, vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT).release());
return semaphoreGroup;
}
-de::MovePtr<tcu::TestCaseGroup> createMemoryTests (tcu::TestContext& testCtx, vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+de::MovePtr<tcu::TestCaseGroup> createMemoryTests (tcu::TestContext& testCtx, vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, externalMemoryTypeToName(externalType), "Tests for external memory"));
de::MovePtr<tcu::TestCaseGroup> hostVisibleGroup (new tcu::TestCaseGroup(testCtx, hostVisible ? "host_visible" : "device_only", ""));
const MemoryTestConfig memoryConfig (externalType, hostVisible, dedicated);
- if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
addFunctionCase(hostVisibleGroup.get(), "create_win32", "Test creating memory with win32 properties .", testMemoryWin32Create, memoryConfig);
}
addFunctionCase(hostVisibleGroup.get(), "import_twice", "Test importing memory object twice.", testMemoryImportTwice, memoryConfig);
addFunctionCase(hostVisibleGroup.get(), "import_multiple_times", "Test importing memory object multiple times.", testMemoryMultimpleImports, memoryConfig);
- if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
{
addFunctionCase(hostVisibleGroup.get(), "dup", "Test calling dup() on exported memory.", testMemoryFdDup, memoryConfig);
addFunctionCase(hostVisibleGroup.get(), "dup2", "Test calling dup2() on exported memory.", testMemoryFdDup2, memoryConfig);
{
de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "memory", "Tests for external memory"));
- group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR).release());
- group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR).release());
- group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR).release());
+ group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT).release());
+ group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT).release());
+ group->addChild(createMemoryTests(testCtx, vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT).release());
return group;
}
}
};
-struct CheckEnumeratePhysicalDeviceGroupsIncompleteResult : public CheckIncompleteResult<VkPhysicalDeviceGroupPropertiesKHR>
+struct CheckEnumeratePhysicalDeviceGroupsIncompleteResult : public CheckIncompleteResult<VkPhysicalDeviceGroupProperties>
{
- void getResult (Context& context, VkPhysicalDeviceGroupPropertiesKHR* data)
+ void getResult (Context& context, VkPhysicalDeviceGroupProperties* data)
{
- m_result = context.getInstanceInterface().enumeratePhysicalDeviceGroupsKHR(context.getInstance(), &m_count, data);
+ m_result = context.getInstanceInterface().enumeratePhysicalDeviceGroups(context.getInstance(), &m_count, data);
}
};
return createDefaultInstance(vkp, version, vector<string>() /* layers */, enabledExts, DE_NULL);
}
-tcu::TestStatus enumeratePhysicalDeviceGroupsKHR (Context& context)
+tcu::TestStatus enumeratePhysicalDeviceGroups (Context& context)
{
TestLog& log = context.getTestContext().getLog();
tcu::ResultCollector results (log);
const PlatformInterface& vkp = context.getPlatformInterface();
const Unique<VkInstance> instance (createInstanceWithExtension(vkp, context.getUsedApiVersion(), "VK_KHR_device_group_creation"));
const InstanceDriver vki (vkp, *instance);
- const vector<VkPhysicalDeviceGroupPropertiesKHR> devicegroups = enumeratePhysicalDeviceGroupsKHR(vki, *instance);
+ const vector<VkPhysicalDeviceGroupProperties> devicegroups = enumeratePhysicalDeviceGroups(vki, *instance);
log << TestLog::Integer("NumDevices", "Number of device groups", "", QP_KEY_TAG_NONE, deInt64(devicegroups.size()));
if (de::beginsWith(*extIter, "VK_KHR_") &&
!de::contains(allowedExtSet, *extIter))
{
- results.fail("Unknown KHR extension " + *extIter);
+ results.fail("Unknown extension " + *extIter);
}
}
}
const deUint32 deviceIdx = vk::chooseDeviceIndex(context.getInstanceInterface(), *instance, cmdLine);
const float queuePriority = 1.0f;
VkPhysicalDeviceMemoryProperties memProps;
- VkPeerMemoryFeatureFlagsKHR* peerMemFeatures;
- deUint8 buffer [sizeof(VkPeerMemoryFeatureFlagsKHR) + GUARD_SIZE];
+ VkPeerMemoryFeatureFlags* peerMemFeatures;
+ deUint8 buffer [sizeof(VkPeerMemoryFeatureFlags) + GUARD_SIZE];
deUint32 numPhysicalDevices = 0;
deUint32 queueFamilyIndex = 0;
- const vector<VkPhysicalDeviceGroupPropertiesKHR> deviceGroupProps = enumeratePhysicalDeviceGroupsKHR(vki, *instance);
- std::vector<const char*> deviceExtensions;
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(vki, *instance);
+ std::vector<const char*> deviceExtensions;
deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
TCU_THROW(NotSupportedError, "Need a device Group with atleast 2 physical devices.");
// Create device groups
- const VkDeviceGroupDeviceCreateInfoKHR deviceGroupInfo =
+ const VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
- VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
- DE_NULL, //pNext
- deviceGroupProps[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
- deviceGroupProps[devGroupIdx].physicalDevices //physicalDevices
+ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, //stype
+ DE_NULL, //pNext
+ deviceGroupProps[devGroupIdx].physicalDeviceCount, //physicalDeviceCount
+ deviceGroupProps[devGroupIdx].physicalDevices //physicalDevices
};
const VkDeviceCreateInfo deviceCreateInfo =
{
const DeviceDriver vk (vki, *deviceGroup);
context.getInstanceInterface().getPhysicalDeviceMemoryProperties(deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx], &memProps);
- peerMemFeatures = reinterpret_cast<VkPeerMemoryFeatureFlagsKHR*>(buffer);
+ peerMemFeatures = reinterpret_cast<VkPeerMemoryFeatureFlags*>(buffer);
deMemset(buffer, GUARD_VALUE, sizeof(buffer));
for (deUint32 heapIndex = 0; heapIndex < memProps.memoryHeapCount; heapIndex++)
{
if (localDeviceIndex != remoteDeviceIndex)
{
- vk.getDeviceGroupPeerMemoryFeaturesKHR(deviceGroup.get(), heapIndex, localDeviceIndex, remoteDeviceIndex, peerMemFeatures);
+ vk.getDeviceGroupPeerMemoryFeatures(deviceGroup.get(), heapIndex, localDeviceIndex, remoteDeviceIndex, peerMemFeatures);
// Check guard
for (deInt32 ndx = 0; ndx < GUARD_SIZE; ndx++)
{
- if (buffer[ndx + sizeof(VkPeerMemoryFeatureFlagsKHR)] != GUARD_VALUE)
+ if (buffer[ndx + sizeof(VkPeerMemoryFeatureFlags)] != GUARD_VALUE)
{
log << TestLog::Message << "deviceGroupPeerMemoryFeatures - Guard offset " << ndx << " not valid" << TestLog::EndMessage;
return tcu::TestStatus::fail("deviceGroupPeerMemoryFeatures buffer overflow");
}
}
- VkPeerMemoryFeatureFlagsKHR requiredFlag = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR;
- VkPeerMemoryFeatureFlagsKHR maxValidFlag = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT_KHR|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT_KHR|
- VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT_KHR|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT_KHR;
+ VkPeerMemoryFeatureFlags requiredFlag = VK_PEER_MEMORY_FEATURE_COPY_DST_BIT;
+ VkPeerMemoryFeatureFlags maxValidFlag = VK_PEER_MEMORY_FEATURE_COPY_SRC_BIT|VK_PEER_MEMORY_FEATURE_COPY_DST_BIT|
+ VK_PEER_MEMORY_FEATURE_GENERIC_SRC_BIT|VK_PEER_MEMORY_FEATURE_GENERIC_DST_BIT;
if ((!(*peerMemFeatures & requiredFlag)) ||
*peerMemFeatures > maxValidFlag)
return tcu::TestStatus::fail("deviceGroupPeerMemoryFeatures invalid flag");
// \todo [2017-05-16 pyry] This should be extended to cover for example COLOR_ATTACHMENT for depth formats etc.
// \todo [2017-05-18 pyry] Any other color conversion related features that can't be supported by regular formats?
- const VkFormatFeatureFlags notAllowedFeatures = VK_FORMAT_FEATURE_DISJOINT_BIT_KHR;
+ const VkFormatFeatureFlags notAllowedFeatures = VK_FORMAT_FEATURE_DISJOINT_BIT;
const struct
return tcu::TestStatus::fail("Required features not supported");
}
-VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR getPhysicalDeviceSamplerYcbcrConversionFeatures (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
+VkPhysicalDeviceSamplerYcbcrConversionFeatures getPhysicalDeviceSamplerYcbcrConversionFeatures (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
{
- VkPhysicalDeviceFeatures2KHR coreFeatures;
- VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ycbcrFeatures;
+ VkPhysicalDeviceFeatures2 coreFeatures;
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcrFeatures;
deMemset(&coreFeatures, 0, sizeof(coreFeatures));
deMemset(&ycbcrFeatures, 0, sizeof(ycbcrFeatures));
- coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
coreFeatures.pNext = &ycbcrFeatures;
- ycbcrFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES_KHR;
+ ycbcrFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES;
- vk.getPhysicalDeviceFeatures2KHR(physicalDevice, &coreFeatures);
+ vk.getPhysicalDeviceFeatures2(physicalDevice, &coreFeatures);
return ycbcrFeatures;
}
TCU_CHECK(de::contains(context.getInstanceExtensions().begin(), context.getInstanceExtensions().end(), "VK_KHR_get_physical_device_properties2"));
{
- const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR ycbcrFeatures = getPhysicalDeviceSamplerYcbcrConversionFeatures(context.getInstanceInterface(), context.getPhysicalDevice());
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures ycbcrFeatures = getPhysicalDeviceSamplerYcbcrConversionFeatures(context.getInstanceInterface(), context.getPhysicalDevice());
if (ycbcrFeatures.samplerYcbcrConversion == VK_FALSE)
TCU_THROW(NotSupportedError, "samplerYcbcrConversion is not supported");
// all formats *may* support these
flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT;
flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_LINEAR_BIT;
- flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR;
- flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT_KHR;
-
- // multi-plane formats *may* support DISJOINT_BIT_KHR
+ flags |= VK_FORMAT_FEATURE_TRANSFER_SRC_BIT;
+ flags |= VK_FORMAT_FEATURE_TRANSFER_DST_BIT;
+ flags |= VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT;
+ flags |= VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
+ flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
+ flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT;
+ flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT;
+ flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT;
+ flags |= VK_FORMAT_FEATURE_SAMPLED_IMAGE_FILTER_MINMAX_BIT;
+
+ // multi-plane formats *may* support DISJOINT_BIT
if (getPlaneCount(format) >= 2)
- flags |= VK_FORMAT_FEATURE_DISJOINT_BIT_KHR;
+ flags |= VK_FORMAT_FEATURE_DISJOINT_BIT;
if (isChromaSubsampled(format))
- flags |= VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR;
+ flags |= VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT;
return flags;
}
};
static const VkFormat s_requiredBaseFormats[] =
{
- VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
- VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR
+ VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+ VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM
};
const bool isRequiredBaseFormat (de::contains(DE_ARRAY_BEGIN(s_requiredBaseFormats), DE_ARRAY_END(s_requiredBaseFormats), format));
if (isRequiredBaseFormat && fields[fieldNdx].requiredFeatures)
{
const VkFormatFeatureFlags required = VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT
- | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR
- | VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR
- | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR;
+ | VK_FORMAT_FEATURE_TRANSFER_SRC_BIT
+ | VK_FORMAT_FEATURE_TRANSFER_DST_BIT
+ | VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT;
if ((supported & required) != required)
{
allOk = false;
}
- if ((supported & (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR)) == 0)
+ if ((supported & (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT)) == 0)
{
log << TestLog::Message << "ERROR in " << fieldName << ":\n"
- << " Either VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR required"
+ << " Either VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT or VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT required"
<< TestLog::EndMessage;
allOk = false;
}
{ (VkFormat)(VK_FORMAT_UNDEFINED+1), VK_CORE_FORMAT_LAST, formatProperties },
// YCbCr formats
- { VK_FORMAT_G8B8G8R8_422_UNORM_KHR, (VkFormat)(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR+1), ycbcrFormatProperties },
+ { VK_FORMAT_G8B8G8R8_422_UNORM, (VkFormat)(VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM+1), ycbcrFormatProperties },
};
for (int rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(s_formatRanges); ++rangeNdx)
if (useKhrMaintenance1Semantics)
{
- if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR) != 0)
+ if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) != 0)
flags |= VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
- if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR) != 0)
+ if ((supportedFeatures & VK_FORMAT_FEATURE_TRANSFER_DST_BIT) != 0)
flags |= VK_IMAGE_USAGE_TRANSFER_DST_BIT;
}
else
if (hasKhrMaintenance1 && (supportedFeatures & VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) != 0)
{
- results.check((supportedFeatures & (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR|VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR)) != 0,
- "A sampled image format must have VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR and VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR format feature flags set");
+ results.check((supportedFeatures & (VK_FORMAT_FEATURE_TRANSFER_SRC_BIT|VK_FORMAT_FEATURE_TRANSFER_DST_BIT)) != 0,
+ "A sampled image format must have VK_FORMAT_FEATURE_TRANSFER_SRC_BIT and VK_FORMAT_FEATURE_TRANSFER_DST_BIT format feature flags set");
}
for (VkImageUsageFlags curUsageFlags = 0; curUsageFlags <= usageFlagSet; curUsageFlags++)
for (size_t deviceNdx = 0; deviceNdx < devices.size(); ++deviceNdx)
{
VkPhysicalDeviceFeatures coreFeatures;
- VkPhysicalDeviceFeatures2KHR extFeatures;
+ VkPhysicalDeviceFeatures2 extFeatures;
deMemset(&coreFeatures, 0xcd, sizeof(coreFeatures));
deMemset(&extFeatures.features, 0xcd, sizeof(extFeatures.features));
- extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
+ extFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
extFeatures.pNext = DE_NULL;
vki.getPhysicalDeviceFeatures(devices[deviceNdx], &coreFeatures);
- vki.getPhysicalDeviceFeatures2KHR(devices[deviceNdx], &extFeatures);
+ vki.getPhysicalDeviceFeatures2(devices[deviceNdx], &extFeatures);
- TCU_CHECK(extFeatures.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR);
+ TCU_CHECK(extFeatures.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2);
TCU_CHECK(extFeatures.pNext == DE_NULL);
if (deMemCmp(&coreFeatures, &extFeatures.features, sizeof(VkPhysicalDeviceFeatures)) != 0)
- TCU_FAIL("Mismatch between features reported by vkGetPhysicalDeviceFeatures and vkGetPhysicalDeviceFeatures2KHR");
+ TCU_FAIL("Mismatch between features reported by vkGetPhysicalDeviceFeatures and vkGetPhysicalDeviceFeatures2");
}
return tcu::TestStatus::pass("Querying device features succeeded");
for (size_t deviceNdx = 0; deviceNdx < devices.size(); ++deviceNdx)
{
VkPhysicalDeviceProperties coreProperties;
- VkPhysicalDeviceProperties2KHR extProperties;
+ VkPhysicalDeviceProperties2 extProperties;
- extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+ extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
extProperties.pNext = DE_NULL;
vki.getPhysicalDeviceProperties(devices[deviceNdx], &coreProperties);
- vki.getPhysicalDeviceProperties2KHR(devices[deviceNdx], &extProperties);
+ vki.getPhysicalDeviceProperties2(devices[deviceNdx], &extProperties);
- TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR);
+ TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2);
TCU_CHECK(extProperties.pNext == DE_NULL);
// We can't use memcmp() here because the structs may contain padding bytes that drivers may or may not
const deUint8* extPropertyBytes = reinterpret_cast<deUint8*>(&extProperties.properties) + offset;
if (deMemCmp(corePropertyBytes, extPropertyBytes, size) != 0)
- TCU_FAIL("Mismatch between properties reported by vkGetPhysicalDeviceProperties and vkGetPhysicalDeviceProperties2KHR");
+ TCU_FAIL("Mismatch between properties reported by vkGetPhysicalDeviceProperties and vkGetPhysicalDeviceProperties2");
}
}
{
const VkFormat format = (VkFormat)formatNdx;
VkFormatProperties coreProperties;
- VkFormatProperties2KHR extProperties;
+ VkFormatProperties2 extProperties;
deMemset(&coreProperties, 0xcd, sizeof(VkFormatProperties));
- deMemset(&extProperties, 0xcd, sizeof(VkFormatProperties2KHR));
+ deMemset(&extProperties, 0xcd, sizeof(VkFormatProperties2));
- extProperties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR;
+ extProperties.sType = VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2;
extProperties.pNext = DE_NULL;
vki.getPhysicalDeviceFormatProperties(physicalDevice, format, &coreProperties);
- vki.getPhysicalDeviceFormatProperties2KHR(physicalDevice, format, &extProperties);
+ vki.getPhysicalDeviceFormatProperties2(physicalDevice, format, &extProperties);
- TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2_KHR);
+ TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_FORMAT_PROPERTIES_2);
TCU_CHECK(extProperties.pNext == DE_NULL);
if (deMemCmp(&coreProperties, &extProperties.formatProperties, sizeof(VkFormatProperties)) != 0)
- TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceFormatProperties2KHR");
+ TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceFormatProperties and vkGetPhysicalDeviceFormatProperties2");
}
}
deUint32 numExtQueueFamilies = ~0u;
vki.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numCoreQueueFamilies, DE_NULL);
- vki.getPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, &numExtQueueFamilies, DE_NULL);
+ vki.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &numExtQueueFamilies, DE_NULL);
TCU_CHECK_MSG(numCoreQueueFamilies == numExtQueueFamilies, "Different number of queue family properties reported");
TCU_CHECK(numCoreQueueFamilies > 0);
{
std::vector<VkQueueFamilyProperties> coreProperties (numCoreQueueFamilies);
- std::vector<VkQueueFamilyProperties2KHR> extProperties (numExtQueueFamilies);
+ std::vector<VkQueueFamilyProperties2> extProperties (numExtQueueFamilies);
deMemset(&coreProperties[0], 0xcd, sizeof(VkQueueFamilyProperties)*numCoreQueueFamilies);
- deMemset(&extProperties[0], 0xcd, sizeof(VkQueueFamilyProperties2KHR)*numExtQueueFamilies);
+ deMemset(&extProperties[0], 0xcd, sizeof(VkQueueFamilyProperties2)*numExtQueueFamilies);
for (size_t ndx = 0; ndx < extProperties.size(); ++ndx)
{
- extProperties[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR;
+ extProperties[ndx].sType = VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2;
extProperties[ndx].pNext = DE_NULL;
}
vki.getPhysicalDeviceQueueFamilyProperties(physicalDevice, &numCoreQueueFamilies, &coreProperties[0]);
- vki.getPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, &numExtQueueFamilies, &extProperties[0]);
+ vki.getPhysicalDeviceQueueFamilyProperties2(physicalDevice, &numExtQueueFamilies, &extProperties[0]);
TCU_CHECK((size_t)numCoreQueueFamilies == coreProperties.size());
TCU_CHECK((size_t)numExtQueueFamilies == extProperties.size());
for (size_t ndx = 0; ndx < extProperties.size(); ++ndx)
{
- TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2_KHR);
+ TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_QUEUE_FAMILY_PROPERTIES_2);
TCU_CHECK(extProperties[ndx].pNext == DE_NULL);
if (deMemCmp(&coreProperties[ndx], &extProperties[ndx].queueFamilyProperties, sizeof(VkQueueFamilyProperties)) != 0)
- TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceQueueFamilyProperties and vkGetPhysicalDeviceQueueFamilyProperties2KHR");
+ TCU_FAIL("Mismatch between format properties reported by vkGetPhysicalDeviceQueueFamilyProperties and vkGetPhysicalDeviceQueueFamilyProperties2");
}
}
}
for (size_t deviceNdx = 0; deviceNdx < devices.size(); ++deviceNdx)
{
- VkPhysicalDeviceMemoryProperties coreProperties;
- VkPhysicalDeviceMemoryProperties2KHR extProperties;
+ VkPhysicalDeviceMemoryProperties coreProperties;
+ VkPhysicalDeviceMemoryProperties2 extProperties;
deMemset(&coreProperties, 0xcd, sizeof(VkPhysicalDeviceMemoryProperties));
- deMemset(&extProperties, 0xcd, sizeof(VkPhysicalDeviceMemoryProperties2KHR));
+ deMemset(&extProperties, 0xcd, sizeof(VkPhysicalDeviceMemoryProperties2));
- extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR;
+ extProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2;
extProperties.pNext = DE_NULL;
vki.getPhysicalDeviceMemoryProperties(devices[deviceNdx], &coreProperties);
- vki.getPhysicalDeviceMemoryProperties2KHR(devices[deviceNdx], &extProperties);
+ vki.getPhysicalDeviceMemoryProperties2(devices[deviceNdx], &extProperties);
- TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2_KHR);
+ TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PROPERTIES_2);
TCU_CHECK(extProperties.pNext == DE_NULL);
if (deMemCmp(&coreProperties, &extProperties.memoryProperties, sizeof(VkPhysicalDeviceMemoryProperties)) != 0)
- TCU_FAIL("Mismatch between properties reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2KHR");
+ TCU_FAIL("Mismatch between properties reported by vkGetPhysicalDeviceMemoryProperties and vkGetPhysicalDeviceMemoryProperties2");
}
return tcu::TestStatus::pass("Querying device memory properties succeeded");
{
for (VkImageCreateFlags curCreateFlags = 0; curCreateFlags <= allCreateFlags; curCreateFlags++)
{
- const VkPhysicalDeviceImageFormatInfo2KHR imageFormatInfo =
+ const VkPhysicalDeviceImageFormatInfo2 imageFormatInfo =
{
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2_KHR,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
DE_NULL,
format,
imageType,
};
VkImageFormatProperties coreProperties;
- VkImageFormatProperties2KHR extProperties;
+ VkImageFormatProperties2 extProperties;
VkResult coreResult;
VkResult extResult;
deMemset(&coreProperties, 0xcd, sizeof(VkImageFormatProperties));
- deMemset(&extProperties, 0xcd, sizeof(VkImageFormatProperties2KHR));
+ deMemset(&extProperties, 0xcd, sizeof(VkImageFormatProperties2));
- extProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR;
+ extProperties.sType = VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2;
extProperties.pNext = DE_NULL;
coreResult = vki.getPhysicalDeviceImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.tiling, imageFormatInfo.usage, imageFormatInfo.flags, &coreProperties);
- extResult = vki.getPhysicalDeviceImageFormatProperties2KHR(physicalDevice, &imageFormatInfo, &extProperties);
+ extResult = vki.getPhysicalDeviceImageFormatProperties2(physicalDevice, &imageFormatInfo, &extProperties);
- TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2_KHR);
+ TCU_CHECK(extProperties.sType == VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2);
TCU_CHECK(extProperties.pNext == DE_NULL);
if ((coreResult != extResult) ||
{
log << TestLog::Message << "ERROR: device " << deviceNdx << ": mismatch with query " << imageFormatInfo << TestLog::EndMessage
<< TestLog::Message << "vkGetPhysicalDeviceImageFormatProperties() returned " << coreResult << ", " << coreProperties << TestLog::EndMessage
- << TestLog::Message << "vkGetPhysicalDeviceImageFormatProperties2KHR() returned " << extResult << ", " << extProperties << TestLog::EndMessage;
- TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceImageFormatProperties and vkGetPhysicalDeviceImageFormatProperties2KHR");
+ << TestLog::Message << "vkGetPhysicalDeviceImageFormatProperties2() returned " << extResult << ", " << extProperties << TestLog::EndMessage;
+ TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceImageFormatProperties and vkGetPhysicalDeviceImageFormatProperties2");
}
}
}
{
for (VkImageUsageFlags curUsageFlags = (VkImageUsageFlags)1; curUsageFlags <= allUsageFlags; curUsageFlags++)
{
- const VkPhysicalDeviceSparseImageFormatInfo2KHR imageFormatInfo =
+ const VkPhysicalDeviceSparseImageFormatInfo2 imageFormatInfo =
{
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2_KHR,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SPARSE_IMAGE_FORMAT_INFO_2,
DE_NULL,
format,
imageType,
// Query count
vki.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.samples, imageFormatInfo.usage, imageFormatInfo.tiling, &numCoreProperties, DE_NULL);
- vki.getPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, &imageFormatInfo, &numExtProperties, DE_NULL);
+ vki.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, &imageFormatInfo, &numExtProperties, DE_NULL);
if (numCoreProperties != numExtProperties)
{
if (numCoreProperties > 0)
{
std::vector<VkSparseImageFormatProperties> coreProperties (numCoreProperties);
- std::vector<VkSparseImageFormatProperties2KHR> extProperties (numExtProperties);
+ std::vector<VkSparseImageFormatProperties2> extProperties (numExtProperties);
deMemset(&coreProperties[0], 0xcd, sizeof(VkSparseImageFormatProperties)*numCoreProperties);
- deMemset(&extProperties[0], 0xcd, sizeof(VkSparseImageFormatProperties2KHR)*numExtProperties);
+ deMemset(&extProperties[0], 0xcd, sizeof(VkSparseImageFormatProperties2)*numExtProperties);
for (deUint32 ndx = 0; ndx < numExtProperties; ++ndx)
{
- extProperties[ndx].sType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR;
+ extProperties[ndx].sType = VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2;
extProperties[ndx].pNext = DE_NULL;
}
vki.getPhysicalDeviceSparseImageFormatProperties(physicalDevice, imageFormatInfo.format, imageFormatInfo.type, imageFormatInfo.samples, imageFormatInfo.usage, imageFormatInfo.tiling, &numCoreProperties, &coreProperties[0]);
- vki.getPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, &imageFormatInfo, &numExtProperties, &extProperties[0]);
+ vki.getPhysicalDeviceSparseImageFormatProperties2(physicalDevice, &imageFormatInfo, &numExtProperties, &extProperties[0]);
TCU_CHECK((size_t)numCoreProperties == coreProperties.size());
TCU_CHECK((size_t)numExtProperties == extProperties.size());
for (deUint32 ndx = 0; ndx < numCoreProperties; ++ndx)
{
- TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2_KHR);
+ TCU_CHECK(extProperties[ndx].sType == VK_STRUCTURE_TYPE_SPARSE_IMAGE_FORMAT_PROPERTIES_2);
TCU_CHECK(extProperties[ndx].pNext == DE_NULL);
if ((deMemCmp(&coreProperties[ndx], &extProperties[ndx].properties, sizeof(VkSparseImageFormatProperties)) != 0))
{
log << TestLog::Message << "ERROR: device " << deviceNdx << ": mismatch with query " << imageFormatInfo << " property " << ndx << TestLog::EndMessage
<< TestLog::Message << "vkGetPhysicalDeviceSparseImageFormatProperties() returned " << coreProperties[ndx] << TestLog::EndMessage
- << TestLog::Message << "vkGetPhysicalDeviceSparseImageFormatProperties2KHR() returned " << extProperties[ndx] << TestLog::EndMessage;
- TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceSparseImageFormatProperties and vkGetPhysicalDeviceSparseImageFormatProperties2KHR");
+ << TestLog::Message << "vkGetPhysicalDeviceSparseImageFormatProperties2() returned " << extProperties[ndx] << TestLog::EndMessage;
+ TCU_FAIL("Mismatch between image format properties reported by vkGetPhysicalDeviceSparseImageFormatProperties and vkGetPhysicalDeviceSparseImageFormatProperties2");
}
}
}
de::MovePtr<tcu::TestCaseGroup> instanceInfoTests (new tcu::TestCaseGroup(testCtx, "instance", "Instance Information Tests"));
addFunctionCase(instanceInfoTests.get(), "physical_devices", "Physical devices", enumeratePhysicalDevices);
- addFunctionCase(instanceInfoTests.get(), "physical_device_groups", "Physical devices Groups", enumeratePhysicalDeviceGroupsKHR);
+ addFunctionCase(instanceInfoTests.get(), "physical_device_groups", "Physical devices Groups", enumeratePhysicalDeviceGroups);
addFunctionCase(instanceInfoTests.get(), "layers", "Layers", enumerateInstanceLayers);
addFunctionCase(instanceInfoTests.get(), "extensions", "Extensions", enumerateInstanceExtensions);
infoTests->addChild(extendedPropertiesTests.release());
}
- infoTests->addChild(createTestGroup(testCtx, "image_format_properties2", "VkGetPhysicalDeviceImageFormatProperties2KHR() Tests", createImageFormatTests, imageFormatProperties2));
- infoTests->addChild(createTestGroup(testCtx, "sparse_image_format_properties2", "VkGetPhysicalDeviceSparseImageFormatProperties2KHR() Tests", createImageFormatTests, sparseImageFormatProperties2));
+ infoTests->addChild(createTestGroup(testCtx, "image_format_properties2", "VkGetPhysicalDeviceImageFormatProperties2() Tests", createImageFormatTests, imageFormatProperties2));
+ infoTests->addChild(createTestGroup(testCtx, "sparse_image_format_properties2", "VkGetPhysicalDeviceSparseImageFormatProperties2() Tests", createImageFormatTests, sparseImageFormatProperties2));
{
de::MovePtr<tcu::TestCaseGroup> androidTests (new tcu::TestCaseGroup(testCtx, "android", "Android CTS Tests"));
, queueFamilyIndex (~0u)
{
{
- const vector<VkPhysicalDeviceGroupPropertiesKHR> devGroupProperties = enumeratePhysicalDeviceGroupsKHR(vki, *instance.object);
+ const vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(vki, *instance.object);
if (devGroupProperties.size() <= (size_t)params.deviceGroupIndex)
TCU_THROW(NotSupportedError, "Device Group not found");
}
};
- const VkDeviceGroupDeviceCreateInfoKHR deviceGroupInfo =
+ const VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
- VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
- DE_NULL, //pNext
- res.physicalDeviceCount, //physicalDeviceCount
- res.physicalDevices.data() //physicalDevices
+ VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO, //stype
+ DE_NULL, //pNext
+ res.physicalDeviceCount, //physicalDeviceCount
+ res.physicalDevices.data() //physicalDevices
};
- const VkDeviceCreateInfo deviceGroupCreateInfo =
+ const VkDeviceCreateInfo deviceGroupCreateInfo =
{
VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO,
&deviceGroupInfo,
(VkDeviceCreateFlags)0,
DE_LENGTH_OF_ARRAY(queues),
queues,
- 0u, // enabledLayerNameCount
- DE_NULL, // ppEnabledLayerNames
- 0u, // enabledExtensionNameCount
- DE_NULL, // ppEnabledExtensionNames
- DE_NULL, // pEnabledFeatures
+ 0u, // enabledLayerNameCount
+ DE_NULL, // ppEnabledLayerNames
+ 0u, // enabledExtensionNameCount
+ DE_NULL, // ppEnabledExtensionNames
+ DE_NULL, // pEnabledFeatures
};
return createDevice(res.vki, res.physicalDevices[params.deviceIndex], &deviceGroupCreateInfo, env.allocationCallbacks);
tcu::clear(tcu::getSubregion(dst, dst.getWidth() / 2, dst.getHeight() / 2, dst.getWidth() - dst.getWidth() / 2, dst.getHeight() - dst.getHeight() / 2), c4);
}
-static const vk::VkDescriptorUpdateTemplateEntryKHR createTemplateBinding (deUint32 binding, deUint32 arrayElement, deUint32 descriptorCount, vk::VkDescriptorType descriptorType, size_t offset, size_t stride)
+static const vk::VkDescriptorUpdateTemplateEntry createTemplateBinding (deUint32 binding, deUint32 arrayElement, deUint32 descriptorCount, vk::VkDescriptorType descriptorType, size_t offset, size_t stride)
{
- const vk::VkDescriptorUpdateTemplateEntryKHR updateBinding =
+ const vk::VkDescriptorUpdateTemplateEntry updateBinding =
{
binding,
arrayElement,
vk::VkBuffer sourceBufferB,
const deUint32 viewOffsetB,
vk::DescriptorSetUpdateBuilder& updateBuilder,
- vk::Move<vk::VkDescriptorUpdateTemplateKHR>& updateTemplate,
+ vk::Move<vk::VkDescriptorUpdateTemplate>& updateTemplate,
RawUpdateRegistry& updateRegistry,
vk::VkPipelineLayout pipelineLayout = DE_NULL);
vk::VkBuffer sourceBufferB,
const deUint32 viewOffsetB,
vk::VkDescriptorSet descriptorSet,
- vk::Move<vk::VkDescriptorUpdateTemplateKHR>& updateTemplate,
+ vk::Move<vk::VkDescriptorUpdateTemplate>& updateTemplate,
RawUpdateRegistry& updateRegistry,
bool withPush = false,
vk::VkPipelineLayout pipelineLayout = 0);
const vk::Unique<vk::VkBuffer> m_sourceBufferA;
const vk::Unique<vk::VkBuffer> m_sourceBufferB;
const vk::Unique<vk::VkDescriptorPool> m_descriptorPool;
- vk::Move<vk::VkDescriptorUpdateTemplateKHR> m_updateTemplate;
+ vk::Move<vk::VkDescriptorUpdateTemplate> m_updateTemplate;
RawUpdateRegistry m_updateRegistry;
vk::DescriptorSetUpdateBuilder m_updateBuilder;
const vk::Unique<vk::VkDescriptorSetLayout> m_descriptorSetLayout;
vk::VkBuffer bufferB,
deUint32 offsetB,
vk::DescriptorSetUpdateBuilder& updateBuilder,
- vk::Move<vk::VkDescriptorUpdateTemplateKHR>& updateTemplate,
+ vk::Move<vk::VkDescriptorUpdateTemplate>& updateTemplate,
RawUpdateRegistry& updateRegistry,
vk::VkPipelineLayout pipelineLayout)
{
vk::VkBuffer bufferB,
const deUint32 offsetB,
vk::VkDescriptorSet descriptorSet,
- vk::Move<vk::VkDescriptorUpdateTemplateKHR>& updateTemplate,
+ vk::Move<vk::VkDescriptorUpdateTemplate>& updateTemplate,
RawUpdateRegistry& updateRegistry,
bool withPush,
vk::VkPipelineLayout pipelineLayout)
vk::makeDescriptorBufferInfo(bufferA, (vk::VkDeviceSize)offsetA, (vk::VkDeviceSize)BUFFER_DATA_SIZE),
vk::makeDescriptorBufferInfo(bufferB, (vk::VkDeviceSize)offsetB, (vk::VkDeviceSize)BUFFER_DATA_SIZE),
};
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // descriptorUpdateEntryCount
DE_NULL, // pDescriptorUpdateEntries
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- updateTemplate = vk::createDescriptorUpdateTemplateKHR(vki, device, &templateCreateInfo);
+ updateTemplate = vk::createDescriptorUpdateTemplate(vki, device, &templateCreateInfo);
if (!withPush)
{
- vki.updateDescriptorSetWithTemplateKHR(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
+ vki.updateDescriptorSetWithTemplate(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
}
}
int numPostBarriers,
const vk::VkBufferMemoryBarrier* postBarriers);
- void submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue, vk::VkDescriptorUpdateTemplateKHR updateTemplate = DE_NULL, const void *rawUpdateData = 0) const;
+ void submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue, vk::VkDescriptorUpdateTemplate updateTemplate = DE_NULL, const void *rawUpdateData = 0) const;
void submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue, vk::DescriptorSetUpdateBuilder& updateBuilder) const;
private:
{
}
-void ComputeCommand::submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue, vk::VkDescriptorUpdateTemplateKHR updateTemplate, const void *rawUpdateData) const
+void ComputeCommand::submitAndWait (deUint32 queueFamilyIndex, vk::VkQueue queue, vk::VkDescriptorUpdateTemplate updateTemplate, const void *rawUpdateData) const
{
const vk::VkCommandPoolCreateInfo cmdPoolCreateInfo =
{
vk::makeDescriptorBufferInfo(viewA, (vk::VkDeviceSize)offsetA, (vk::VkDeviceSize)sizeof(tcu::Vec4[2])),
vk::makeDescriptorBufferInfo(viewB, (vk::VkDeviceSize)offsetB, (vk::VkDeviceSize)sizeof(tcu::Vec4[2])),
};
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // descriptorUpdateEntryCount
DE_NULL, // pDescriptorUpdateEntries
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_COMPUTE,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- m_updateTemplate = vk::createDescriptorUpdateTemplateKHR(m_vki, m_device, &templateCreateInfo);
+ m_updateTemplate = vk::createDescriptorUpdateTemplate(m_vki, m_device, &templateCreateInfo);
if (!withPush)
{
- m_vki.updateDescriptorSetWithTemplateKHR(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
+ m_vki.updateDescriptorSetWithTemplate(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
}
}
vk::VkPipelineLayout pipelineLayout)
{
DE_UNREF(pool);
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- updateTemplate = vk::createDescriptorUpdateTemplateKHR(vki, device, &templateCreateInfo);
+ updateTemplate = vk::createDescriptorUpdateTemplate(vki, device, &templateCreateInfo);
if (!withPush)
{
- vki.updateDescriptorSetWithTemplateKHR(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
+ vki.updateDescriptorSetWithTemplate(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
}
}
makeDescriptorImageInfo(m_images.getImageViewA(), imageLayout),
makeDescriptorImageInfo(m_images.getImageViewB(), imageLayout),
};
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_COMPUTE,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- m_updateTemplate = vk::createDescriptorUpdateTemplateKHR(m_vki, m_device, &templateCreateInfo);
+ m_updateTemplate = vk::createDescriptorUpdateTemplate(m_vki, m_device, &templateCreateInfo);
if (!withPush)
{
- m_vki.updateDescriptorSetWithTemplateKHR(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
+ m_vki.updateDescriptorSetWithTemplate(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
}
}
const deUint32 samplerLocation = shaderInterface == SHADER_INPUT_MULTIPLE_DISCONTIGUOUS_DESCRIPTORS ? 1u : 0u;
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- updateTemplate = vk::createDescriptorUpdateTemplateKHR(vki, device, &templateCreateInfo);
+ updateTemplate = vk::createDescriptorUpdateTemplate(vki, device, &templateCreateInfo);
if (!withPush)
{
- vki.updateDescriptorSetWithTemplateKHR(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
+ vki.updateDescriptorSetWithTemplate(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
}
}
vk::makeDescriptorImageInfo(samplers[1], images.getImageViewB(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
};
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- updateTemplate = vk::createDescriptorUpdateTemplateKHR(vki, device, &templateCreateInfo);
+ updateTemplate = vk::createDescriptorUpdateTemplate(vki, device, &templateCreateInfo);
if (!withPush)
{
- vki.updateDescriptorSetWithTemplateKHR(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
+ vki.updateDescriptorSetWithTemplate(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
}
}
void ImageSampleComputeInstance::writeSamplerDescriptorSetWithTemplate (vk::VkDescriptorSet descriptorSet, vk::VkDescriptorSetLayout layout, bool withPush, vk::VkPipelineLayout pipelineLayout)
{
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
const vk::VkDescriptorBufferInfo resultInfo = vk::makeDescriptorBufferInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
const vk::VkDescriptorImageInfo imageInfo = makeDescriptorImageInfo(m_images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL);
const vk::VkDescriptorImageInfo samplersInfos[2] =
makeDescriptorImageInfo(m_images.getSamplerA()),
makeDescriptorImageInfo(m_images.getSamplerB()),
};
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_COMPUTE,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- m_updateTemplate = vk::createDescriptorUpdateTemplateKHR(m_vki, m_device, &templateCreateInfo);
+ m_updateTemplate = vk::createDescriptorUpdateTemplate(m_vki, m_device, &templateCreateInfo);
if (!withPush)
{
- m_vki.updateDescriptorSetWithTemplateKHR(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
+ m_vki.updateDescriptorSetWithTemplate(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
}
}
void ImageSampleComputeInstance::writeImageSamplerDescriptorSetWithTemplate (vk::VkDescriptorSet descriptorSet, vk::VkDescriptorSetLayout layout, bool withPush, vk::VkPipelineLayout pipelineLayout)
{
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
const vk::VkDescriptorBufferInfo resultInfo = vk::makeDescriptorBufferInfo(m_result.getBuffer(), 0u, (vk::VkDeviceSize)ComputeInstanceResultBuffer::DATA_SIZE);
const vk::VkSampler samplers[2] =
{
makeDescriptorImageInfo(samplers[0], m_images.getImageViewA(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
makeDescriptorImageInfo(samplers[1], m_images.getImageViewB(), vk::VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL),
};
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_COMPUTE,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- m_updateTemplate = vk::createDescriptorUpdateTemplateKHR(m_vki, m_device, &templateCreateInfo);
+ m_updateTemplate = vk::createDescriptorUpdateTemplate(m_vki, m_device, &templateCreateInfo);
if (!withPush)
{
- m_vki.updateDescriptorSetWithTemplateKHR(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
+ m_vki.updateDescriptorSetWithTemplate(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
}
}
viewA,
viewB,
};
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_GRAPHICS,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- updateTemplate = vk::createDescriptorUpdateTemplateKHR(vki, device, &templateCreateInfo);
+ updateTemplate = vk::createDescriptorUpdateTemplate(vki, device, &templateCreateInfo);
if (!withPush)
{
- vki.updateDescriptorSetWithTemplateKHR(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
+ vki.updateDescriptorSetWithTemplate(device, descriptorSet, *updateTemplate, updateRegistry.getRawPointer());
}
}
m_texelBuffers.getBufferViewA(),
m_texelBuffers.getBufferViewB(),
};
- std::vector<vk::VkDescriptorUpdateTemplateEntryKHR> updateEntries;
- vk::VkDescriptorUpdateTemplateCreateInfoKHR templateCreateInfo =
+ std::vector<vk::VkDescriptorUpdateTemplateEntry> updateEntries;
+ vk::VkDescriptorUpdateTemplateCreateInfo templateCreateInfo =
{
vk::VK_STRUCTURE_TYPE_DESCRIPTOR_UPDATE_TEMPLATE_CREATE_INFO_KHR,
DE_NULL,
0,
0, // updateCount
DE_NULL, // pUpdates
- withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS_KHR : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET_KHR,
+ withPush ? vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_PUSH_DESCRIPTORS : vk::VK_DESCRIPTOR_UPDATE_TEMPLATE_TYPE_DESCRIPTOR_SET,
layout,
vk::VK_PIPELINE_BIND_POINT_COMPUTE,
pipelineLayout,
templateCreateInfo.pDescriptorUpdateEntries = &updateEntries[0];
templateCreateInfo.descriptorUpdateEntryCount = (deUint32)updateEntries.size();
- m_updateTemplate = vk::createDescriptorUpdateTemplateKHR(m_vki, m_device, &templateCreateInfo);
+ m_updateTemplate = vk::createDescriptorUpdateTemplate(m_vki, m_device, &templateCreateInfo);
if (!withPush)
{
- m_vki.updateDescriptorSetWithTemplateKHR(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
+ m_vki.updateDescriptorSetWithTemplate(m_device, descriptorSet, *m_updateTemplate, m_updateRegistry.getRawPointer());
}
}
LINE_ORIENTATION_DIAGONAL,
};
-const VkPointClippingBehaviorKHR invalidClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_LAST;
+const VkPointClippingBehavior invalidClippingBehavior = VK_POINT_CLIPPING_BEHAVIOR_LAST;
-VkPointClippingBehaviorKHR getClippingBehavior (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
+VkPointClippingBehavior getClippingBehavior (const InstanceInterface& vk, VkPhysicalDevice physicalDevice)
{
- VkPhysicalDevicePointClippingPropertiesKHR behaviorProperties =
+ VkPhysicalDevicePointClippingProperties behaviorProperties =
{
- VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES_KHR, // VkStructureType sType
- DE_NULL, // void* pNext
- invalidClippingBehavior // VkPointClippingBehaviorKHR pointClippingBehavior
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_POINT_CLIPPING_PROPERTIES, // VkStructureType sType
+ DE_NULL, // void* pNext
+ invalidClippingBehavior // VkPointClippingBehavior pointClippingBehavior
};
- VkPhysicalDeviceProperties2KHR properties2;
+ VkPhysicalDeviceProperties2 properties2;
DE_ASSERT(getPointClippingBehaviorName(invalidClippingBehavior) == DE_NULL);
properties2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
properties2.pNext = &behaviorProperties;
- vk.getPhysicalDeviceProperties2KHR(physicalDevice, &properties2);
+ vk.getPhysicalDeviceProperties2(physicalDevice, &properties2);
return behaviorProperties.pointClippingBehavior;
}
if (de::contains(context.getDeviceExtensions().begin(), context.getDeviceExtensions().end(), "VK_KHR_maintenance2"))
{
- VkPointClippingBehaviorKHR clippingBehavior = getClippingBehavior(context.getInstanceInterface(), context.getPhysicalDevice());
+ VkPointClippingBehavior clippingBehavior = getClippingBehavior(context.getInstanceInterface(), context.getPhysicalDevice());
switch (clippingBehavior)
{
- case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES_KHR: pointClippingOutside = true; break;
- case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY_KHR: pointClippingOutside = false; break;
+ case VK_POINT_CLIPPING_BEHAVIOR_ALL_CLIP_PLANES: pointClippingOutside = true; break;
+ case VK_POINT_CLIPPING_BEHAVIOR_USER_CLIP_PLANES_ONLY: pointClippingOutside = false; break;
case invalidClippingBehavior: TCU_FAIL("Clipping behavior read failure"); break;
default:
{
const float queuePriority = 1.0f;
const std::vector<std::string> requiredExtensions (1, "VK_KHR_device_group_creation");
m_deviceGroupInstance = createInstanceWithExtensions(m_context.getPlatformInterface(), m_context.getUsedApiVersion(), requiredExtensions);
- std::vector<VkPhysicalDeviceGroupPropertiesKHR> devGroupProperties = enumeratePhysicalDeviceGroupsKHR(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
+ std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
m_numPhysDevices = devGroupProperties[devGroupIdx].physicalDeviceCount;
std::vector<const char*> deviceExtensions;
deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
- VkDeviceGroupDeviceCreateInfoKHR deviceGroupInfo =
+ VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
DE_NULL, //pNext
deUint32 groupCountZ = ((physDevIdx == (m_numPhysDevices - 1)) && (m_splitWorkSize.z() != m_workSize.z())) ? m_workSize.z() - baseGroupZ : m_splitWorkSize.z();
totalWorkloadSize += (groupCountX * groupCountY * groupCountZ);
- vk.cmdDispatchBaseKHR(*cmdBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
+ vk.cmdDispatchBase(*cmdBuffer, baseGroupX, baseGroupY, baseGroupZ, groupCountX, groupCountY, groupCountZ);
}
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
if (memoryTypeNdx == deviceMemProps.memoryTypeCount)
TCU_THROW(NotSupportedError, "No compatible memory type found");
- const VkMemoryAllocateFlagsInfoKHR allocDeviceMaskInfo =
+ const VkMemoryAllocateFlagsInfo allocDeviceMaskInfo =
{
VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR, // sType
DE_NULL, // pNext
- VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR, // flags
+ VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT, // flags
allocDeviceMask, // deviceMask
};
vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_COMPUTE, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_HOST_BIT, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &hostUniformWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
- vk.cmdSetDeviceMaskKHR(*cmdBuffer, physDevMask);
+ vk.cmdSetDeviceMask(*cmdBuffer, physDevMask);
vk.cmdDispatch(*cmdBuffer, m_workSize.x(), m_workSize.y(), m_workSize.z());
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &shaderWriteBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
const deUint32 deviceMask = 1 << physDevIdx;
beginCommandBuffer(vk, *cmdBuffer);
- vk.cmdSetDeviceMaskKHR(*cmdBuffer, deviceMask);
+ vk.cmdSetDeviceMask(*cmdBuffer, deviceMask);
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT , VK_PIPELINE_STAGE_TRANSFER_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &srcBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
vk.cmdCopyBuffer(*cmdBuffer, *sboBuffer, *checkBuffer, 1, ©Params);
vk.cmdPipelineBarrier(*cmdBuffer, VK_PIPELINE_STAGE_TRANSFER_BIT, VK_PIPELINE_STAGE_HOST_BIT, (VkDependencyFlags)0, 0, (const VkMemoryBarrier*)DE_NULL, 1, &dstBufferBarrier, 0, (const VkImageMemoryBarrier*)DE_NULL);
{
const Unique<VkFence> fence(createFence(vk, device));
- VkDeviceGroupSubmitInfoKHR deviceGroupSubmitInfo =
+ VkDeviceGroupSubmitInfo deviceGroupSubmitInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
imageData[imageNdx].addImage(MovePtr<Image>(new Image(vk, device, allocator, imageData[imageNdx].getImageInfo(infoNdx), MemoryRequirement::Any)));
if (isCompressed)
{
- const VkImageViewUsageCreateInfoKHR imageViewUsageKHR =
+ const VkImageViewUsageCreateInfo imageViewUsageKHR =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
};
const VkImageUsageFlags compressedViewUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
- const VkImageViewUsageCreateInfoKHR compressedViewUsageCI =
+ const VkImageViewUsageCreateInfo compressedViewUsageCI =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
ImagesArray m_uncompressedImages;
MovePtr<Image> m_compressedImage;
- VkImageViewUsageCreateInfoKHR m_imageViewUsageKHR;
- VkImageViewUsageCreateInfoKHR* m_srcImageViewUsageKHR;
- VkImageViewUsageCreateInfoKHR* m_dstImageViewUsageKHR;
+ VkImageViewUsageCreateInfo m_imageViewUsageKHR;
+ VkImageViewUsageCreateInfo* m_srcImageViewUsageKHR;
+ VkImageViewUsageCreateInfo* m_dstImageViewUsageKHR;
std::vector<tcu::UVec3> m_compressedImageResVec;
std::vector<tcu::UVec3> m_uncompressedImageResVec;
VkFormat m_srcFormat;
void GraphicsAttachmentsTestInstance::prepareData ()
{
- VkImageViewUsageCreateInfoKHR* imageViewUsageKHRNull = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
+ VkImageViewUsageCreateInfo* imageViewUsageKHRNull = (VkImageViewUsageCreateInfo*)DE_NULL;
m_imageViewUsageKHR = makeImageViewUsageCreateInfo(m_parameters.compressedImageViewUsage);
Move<VkImageView> refSrcImageView (makeImageView(vk, device, refSrcImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, subresourceRange));
const VkImageUsageFlags resSrcImageUsageFlags = VK_IMAGE_USAGE_SAMPLED_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT;
- const VkImageViewUsageCreateInfoKHR resSrcImageViewUsageKHR = makeImageViewUsageCreateInfo(resSrcImageUsageFlags);
+ const VkImageViewUsageCreateInfo resSrcImageViewUsageKHR = makeImageViewUsageCreateInfo(resSrcImageUsageFlags);
Move<VkImageView> resSrcImageView (makeImageView(vk, device, resCompressedImage->get(), mapImageViewType(m_parameters.imageType), m_parameters.formatCompressed, resSubresourceRange, &resSrcImageViewUsageKHR));
const VkImageCreateFlags refDstImageCreateFlags = 0;
void UploadDownloadExecutor::uploadStore(Context& context)
{
- const vk::VkImageViewUsageCreateInfoKHR viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_STORAGE_BIT, // VkImageUsageFlags usage;
for (deUint32 subpassNdx = 0; subpassNdx < m_caseDef.numLayers; ++subpassNdx)
{
- const vk::VkImageViewUsageCreateInfoKHR viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT, // VkImageUsageFlags usage;
m_dTex.outImageAlloc = bindImage(m_vk, m_device, m_allocator, *m_dTex.outImage, MemoryRequirement::Any);
m_dTex.outImageView = makeImageView(m_vk, m_device, *m_dTex.outImage, getImageViewType(m_caseDef.imageType), m_caseDef.viewFormat, makeColorSubresourceRange(0, m_caseDef.numLayers));
- const vk::VkImageViewUsageCreateInfoKHR viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_SAMPLED_BIT, // VkImageUsageFlags usage;
m_dLoad.outImageAlloc = bindImage(m_vk, m_device, m_allocator, *m_dLoad.outImage, MemoryRequirement::Any);
m_dLoad.outImageView = makeImageView(m_vk, m_device, *m_dLoad.outImage, getImageViewType(m_caseDef.imageType), m_caseDef.viewFormat, makeColorSubresourceRange(0, m_caseDef.numLayers));
- const vk::VkImageViewUsageCreateInfoKHR viewUsageCreateInfo = {
+ const vk::VkImageViewUsageCreateInfo viewUsageCreateInfo = {
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
VK_IMAGE_USAGE_STORAGE_BIT, // VkImageUsageFlags usage;
const VkImageViewType imageViewType,
const VkFormat format,
const VkImageSubresourceRange subresourceRange,
- const VkImageViewUsageCreateInfoKHR* ImageUsageCreateInfoKHR)
+ const VkImageViewUsageCreateInfo* ImageUsageCreateInfo)
{
const VkImageViewCreateInfo imageViewParams =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
- ImageUsageCreateInfoKHR, // const void* pNext;
+ ImageUsageCreateInfo, // const void* pNext;
0u, // VkImageViewCreateFlags flags;
image, // VkImage image;
imageViewType, // VkImageViewType viewType;
return barrier;
}
-VkImageViewUsageCreateInfoKHR makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags)
+VkImageViewUsageCreateInfo makeImageViewUsageCreateInfo (const VkImageUsageFlags imageUsageFlags)
{
- VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR =
+ VkImageViewUsageCreateInfo imageViewUsageCreateInfo =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
imageUsageFlags, //VkImageUsageFlags usage;
};
- return imageViewUsageCreateInfoKHR;
+ return imageViewUsageCreateInfo;
}
VkSamplerCreateInfo makeSamplerCreateInfo ()
const vk::VkImageViewType imageViewType,
const vk::VkFormat format,
const vk::VkImageSubresourceRange subresourceRange,
- const vk::VkImageViewUsageCreateInfoKHR* ImageUsageCreateInfoKHR = DE_NULL);
+ const vk::VkImageViewUsageCreateInfo* ImageUsageCreateInfoKHR = DE_NULL);
vk::Move<vk::VkDescriptorSet> makeDescriptorSet (const vk::DeviceInterface& vk,
const vk::VkDevice device,
const vk::VkImage image,
const vk::VkImageSubresourceRange subresourceRange);
-vk::VkImageViewUsageCreateInfoKHR makeImageViewUsageCreateInfo (const vk::VkImageUsageFlags imageUsageFlags);
+vk::VkImageViewUsageCreateInfo makeImageViewUsageCreateInfo (const vk::VkImageUsageFlags imageUsageFlags);
vk::VkSamplerCreateInfo makeSamplerCreateInfo ();
const UVec3& size,
const VkImageUsageFlags usageFlags,
const bool extendedImageCreateFlag);
- VkImageViewUsageCreateInfoKHR makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags);
+ VkImageViewUsageCreateInfo makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags);
VkDeviceSize getUncompressedImageData (const VkFormat format,
const UVec3& size,
std::vector<deUint8>& data);
Allocator& allocator = m_context.getDefaultAllocator();
const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
- const VkImageViewUsageCreateInfoKHR* imageViewUsageNull = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
- const VkImageViewUsageCreateInfoKHR imageViewUsage = makeImageViewUsageCreateInfo(m_parameters.testedImageUsage);
+ const VkImageViewUsageCreateInfo* imageViewUsageNull = (VkImageViewUsageCreateInfo*)DE_NULL;
+ const VkImageViewUsageCreateInfo imageViewUsage = makeImageViewUsageCreateInfo(m_parameters.testedImageUsage);
const VkFormat srcFormat = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? m_parameters.featurelessFormat :
(m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.featuredFormat :
const VkImageUsageFlags srcImageUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? m_parameters.testedImageUsage :
(m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.pairedImageUsage :
0;
- const VkImageViewUsageCreateInfoKHR* srcImageViewUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? &imageViewUsage :
+ const VkImageViewUsageCreateInfo* srcImageViewUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? &imageViewUsage :
(m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? imageViewUsageNull :
imageViewUsageNull;
const VkDeviceSize srcImageSizeInBytes = getUncompressedImageData(srcFormat, m_parameters.size, srcData);
const VkImageUsageFlags dstImageUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? m_parameters.pairedImageUsage :
(m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? m_parameters.testedImageUsage :
0;
- const VkImageViewUsageCreateInfoKHR* dstImageViewUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? imageViewUsageNull :
+ const VkImageViewUsageCreateInfo* dstImageViewUsageFlags = (m_parameters.operation == OPERATION_ATTACHMENT_READ) ? imageViewUsageNull :
(m_parameters.operation == OPERATION_ATTACHMENT_WRITE) ? &imageViewUsage :
imageViewUsageNull;
const VkDeviceSize dstImageSizeInBytes = getUncompressedImageSizeInBytes(dstFormat, m_parameters.size);
return createImageInfo;
}
-VkImageViewUsageCreateInfoKHR GraphicsAttachmentsTestInstance::makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags)
+VkImageViewUsageCreateInfo GraphicsAttachmentsTestInstance::makeImageViewUsageCreateInfo (VkImageUsageFlags imageUsageFlags)
{
- VkImageViewUsageCreateInfoKHR imageViewUsageCreateInfoKHR =
+ VkImageViewUsageCreateInfo imageViewUsageCreateInfo =
{
VK_STRUCTURE_TYPE_IMAGE_VIEW_USAGE_CREATE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
imageUsageFlags, //VkImageUsageFlags usage;
};
- return imageViewUsageCreateInfoKHR;
+ return imageViewUsageCreateInfo;
}
VkDeviceSize GraphicsAttachmentsTestInstance::getUncompressedImageData (const VkFormat format, const UVec3& size, std::vector<deUint8>& data)
Allocator& allocator = m_context.getDefaultAllocator();
const VkImageSubresourceRange subresourceRange = makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, SINGLE_LEVEL, 0u, SINGLE_LAYER);
- const VkImageViewUsageCreateInfoKHR* imageViewUsageNull = (VkImageViewUsageCreateInfoKHR*)DE_NULL;
- const VkImageViewUsageCreateInfoKHR imageViewUsage = makeImageViewUsageCreateInfo(m_parameters.testedImageUsage);
+ const VkImageViewUsageCreateInfo* imageViewUsageNull = (VkImageViewUsageCreateInfo*)DE_NULL;
+ const VkImageViewUsageCreateInfo imageViewUsage = makeImageViewUsageCreateInfo(m_parameters.testedImageUsage);
const VkFormat srcFormat = (m_parameters.operation == OPERATION_TEXTURE_READ) ? m_parameters.featurelessFormat :
(m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.featuredFormat :
const VkImageUsageFlags srcImageUsageFlags = (m_parameters.operation == OPERATION_TEXTURE_READ) ? m_parameters.testedImageUsage :
(m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.pairedImageUsage :
0;
- const VkImageViewUsageCreateInfoKHR* srcImageViewUsage = (m_parameters.operation == OPERATION_TEXTURE_READ) ? &imageViewUsage :
+ const VkImageViewUsageCreateInfo* srcImageViewUsage = (m_parameters.operation == OPERATION_TEXTURE_READ) ? &imageViewUsage :
(m_parameters.operation == OPERATION_TEXTURE_WRITE) ? imageViewUsageNull :
imageViewUsageNull;
const VkDeviceSize srcImageSizeInBytes = getUncompressedImageData(srcFormat, m_parameters.size, srcData);
const VkImageUsageFlags dstImageUsageFlags = (m_parameters.operation == OPERATION_TEXTURE_READ) ? m_parameters.pairedImageUsage :
(m_parameters.operation == OPERATION_TEXTURE_WRITE) ? m_parameters.testedImageUsage :
0;
- const VkImageViewUsageCreateInfoKHR* dstImageViewUsage = (m_parameters.operation == OPERATION_TEXTURE_READ) ? imageViewUsageNull :
+ const VkImageViewUsageCreateInfo* dstImageViewUsage = (m_parameters.operation == OPERATION_TEXTURE_READ) ? imageViewUsageNull :
(m_parameters.operation == OPERATION_TEXTURE_WRITE) ? &imageViewUsage :
imageViewUsageNull;
const VkDeviceSize dstImageSizeInBytes = getUncompressedImageSizeInBytes(dstFormat, m_parameters.size);
createDeviceGroup();
m_allocFlagsInfo.sType = VK_STRUCTURE_TYPE_MEMORY_ALLOCATE_FLAGS_INFO_KHR;
m_allocFlagsInfo.pNext = DE_NULL;
- m_allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT_KHR;
+ m_allocFlagsInfo.flags = VK_MEMORY_ALLOCATE_DEVICE_MASK_BIT;
m_allocFlagsInfo.deviceMask = 0;
}
protected:
bool m_useDeviceGroups;
bool m_subsetAllocationAllowed;
- VkMemoryAllocateFlagsInfoKHR m_allocFlagsInfo;
+ VkMemoryAllocateFlagsInfo m_allocFlagsInfo;
deUint32 m_numPhysDevices;
VkPhysicalDeviceMemoryProperties m_memoryProperties;
deUint32 queueFamilyIndex = 0;
const std::vector<std::string> requiredExtensions (1, "VK_KHR_device_group_creation");
m_deviceGroupInstance = createInstanceWithExtensions(m_context.getPlatformInterface(), m_context.getUsedApiVersion(), requiredExtensions);
- std::vector<VkPhysicalDeviceGroupPropertiesKHR> devGroupProperties = enumeratePhysicalDeviceGroupsKHR(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
+ std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
m_numPhysDevices = devGroupProperties[devGroupIdx].physicalDeviceCount;
m_subsetAllocationAllowed = devGroupProperties[devGroupIdx].subsetAllocation;
if (m_numPhysDevices < 2)
TCU_THROW(NotSupportedError, "Device group allocation tests not supported with 1 physical device");
std::vector<const char*> deviceExtensions (1, "VK_KHR_device_group");
- VkDeviceGroupDeviceCreateInfoKHR deviceGroupInfo =
+ VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
DE_NULL, //pNext
&queueInfo, // const VkDeviceQueueCreateInfo* pQueueCreateInfos;
0u, // uint32_t enabledLayerCount;
DE_NULL, // const char* const* ppEnabledLayerNames;
- deUint32(deviceExtensions.size()), // uint32_t enabledExtensionCount;
- &deviceExtensions[0], // const char* const* ppEnabledExtensionNames;
+ deUint32(deviceExtensions.size()), // uint32_t enabledExtensionCount;
+ &deviceExtensions[0], // const char* const* ppEnabledExtensionNames;
&deviceFeatures, // const VkPhysicalDeviceFeatures* pEnabledFeatures;
};
m_logicalDevice = createDevice(instance, deviceGroupInfo.pPhysicalDevices[physDeviceIdx], &deviceInfo);
using namespace vk;
-typedef const VkMemoryDedicatedAllocateInfoKHR ConstDedicatedInfo;
+typedef const VkMemoryDedicatedAllocateInfo ConstDedicatedInfo;
typedef de::SharedPtr<Move<VkDeviceMemory> > MemoryRegionPtr;
typedef std::vector<MemoryRegionPtr> MemoryRegionsList;
typedef de::SharedPtr<Move<VkBuffer> > BufferPtr;
typedef std::vector<BufferPtr> BuffersList;
typedef de::SharedPtr<Move<VkImage> > ImagePtr;
typedef std::vector<ImagePtr> ImagesList;
-typedef std::vector<VkBindBufferMemoryInfoKHR> BindBufferMemoryInfosList;
-typedef std::vector<VkBindImageMemoryInfoKHR> BindImageMemoryInfosList;
+typedef std::vector<VkBindBufferMemoryInfo> BindBufferMemoryInfosList;
+typedef std::vector<VkBindImageMemoryInfo> BindImageMemoryInfosList;
class MemoryMappingRAII
{
return dedicatedAllocationInfo;
}
-const VkBindBufferMemoryInfoKHR makeBufferMemoryBindingInfo (VkBuffer buffer,
+const VkBindBufferMemoryInfo makeBufferMemoryBindingInfo (VkBuffer buffer,
VkDeviceMemory memory)
{
- const VkBindBufferMemoryInfoKHR bufferMemoryBinding =
+ const VkBindBufferMemoryInfo bufferMemoryBinding =
{
VK_STRUCTURE_TYPE_BIND_BUFFER_MEMORY_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
return bufferMemoryBinding;
}
-const VkBindImageMemoryInfoKHR makeImageMemoryBindingInfo (VkImage image,
+const VkBindImageMemoryInfo makeImageMemoryBindingInfo (VkImage image,
VkDeviceMemory memory)
{
- const VkBindImageMemoryInfoKHR imageMemoryBinding =
+ const VkBindImageMemoryInfo imageMemoryBinding =
{
VK_STRUCTURE_TYPE_BIND_IMAGE_MEMORY_INFO_KHR, // VkStructureType sType;
DE_NULL, // const void* pNext;
bindMemoryInfos.push_back(makeBufferMemoryBindingInfo(**targets[i], **memory[i]));
}
- VK_CHECK(vk.bindBufferMemory2KHR(vkDevice, count, &bindMemoryInfos.front()));
+ VK_CHECK(vk.bindBufferMemory2(vkDevice, count, &bindMemoryInfos.front()));
}
template<>
bindMemoryInfos.push_back(makeImageMemoryBindingInfo(**targets[i], **memory[i]));
}
- VK_CHECK(vk.bindImageMemory2KHR(vkDevice, count, &bindMemoryInfos.front()));
+ VK_CHECK(vk.bindImageMemory2(vkDevice, count, &bindMemoryInfos.front()));
}
template <typename TTarget>
VkMemoryRequirements getImageMemoryRequirements(const DeviceInterface& vk, VkDevice device, Move<VkImage>& image)
{
- VkImageMemoryRequirementsInfo2KHR info =
+ VkImageMemoryRequirementsInfo2 info =
{
- VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, // VkStructureType sType
- DE_NULL, // const void* pNext
- *image // VkImage image
+ VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ *image // VkImage image
};
- VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, // VkStructureType sType
- DE_NULL, // const void* pNext
- VK_FALSE, // VkBool32 prefersDedicatedAllocation
- VK_FALSE // VkBool32 requiresDedicatedAllocation
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ VK_FALSE, // VkBool32 prefersDedicatedAllocation
+ VK_FALSE // VkBool32 requiresDedicatedAllocation
};
- VkMemoryRequirements2KHR req2 =
+ VkMemoryRequirements2 req2 =
{
- VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, // VkStructureType sType
- &dedicatedRequirements, // void* pNext
- {0, 0, 0} // VkMemoryRequirements memoryRequirements
+ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
+ &dedicatedRequirements, // void* pNext
+ {0, 0, 0} // VkMemoryRequirements memoryRequirements
};
- vk.getImageMemoryRequirements2KHR(device, &info, &req2);
+ vk.getImageMemoryRequirements2(device, &info, &req2);
return req2.memoryRequirements;
}
VkMemoryRequirements getBufferMemoryRequirements(const DeviceInterface& vk, VkDevice device, Move<VkBuffer>& buffer)
{
- VkBufferMemoryRequirementsInfo2KHR info =
+ VkBufferMemoryRequirementsInfo2 info =
{
- VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, // VkStructureType sType
- DE_NULL, // const void* pNext
- *buffer // VkImage image
+ VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ *buffer // VkImage image
};
- VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
- VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, // VkStructureType sType
- DE_NULL, // const void* pNext
- VK_FALSE, // VkBool32 prefersDedicatedAllocation
- VK_FALSE // VkBool32 requiresDedicatedAllocation
+ VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS, // VkStructureType sType
+ DE_NULL, // const void* pNext
+ VK_FALSE, // VkBool32 prefersDedicatedAllocation
+ VK_FALSE // VkBool32 requiresDedicatedAllocation
};
- VkMemoryRequirements2KHR req2 =
+ VkMemoryRequirements2 req2 =
{
- VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, // VkStructureType sType
+ VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2, // VkStructureType sType
&dedicatedRequirements, // void* pNext
{0, 0, 0} // VkMemoryRequirements memoryRequirements
};
- vk.getBufferMemoryRequirements2KHR(device, &info, &req2);
+ vk.getBufferMemoryRequirements2(device, &info, &req2);
return req2.memoryRequirements;
}
{
DE_ASSERT((!image) || (!buffer));
- const VkMemoryDedicatedAllocateInfoKHR
+ const VkMemoryDedicatedAllocateInfo
dedicatedAllocateInfo =
{
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR, // VkStructureType sType
VkMemoryRequirements getBufferMemoryRequirements2 (const DeviceInterface& vk, const VkDevice device, const VkDeviceSize size, const VkBufferCreateFlags flags, const VkBufferUsageFlags usage, void* next = DE_NULL)
{
const Unique<VkBuffer> buffer (makeBuffer(vk, device, size, flags, usage));
- VkBufferMemoryRequirementsInfo2KHR info =
+ VkBufferMemoryRequirementsInfo2 info =
{
VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
*buffer // VkBuffer buffer
};
- VkMemoryRequirements2KHR req2 =
+ VkMemoryRequirements2 req2 =
{
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, // VkStructureType sType
next, // void* pNext
{0, 0, 0} // VkMemoryRequirements memoryRequirements
};
- vk.getBufferMemoryRequirements2KHR(device, &info, &req2);
+ vk.getBufferMemoryRequirements2(device, &info, &req2);
return req2.memoryRequirements;
}
{
const Unique<VkImage> image(createImage(vk, device, &createInfo));
- VkImageMemoryRequirementsInfo2KHR info =
+ VkImageMemoryRequirementsInfo2 info =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR, // VkStructureType sType
DE_NULL, // const void* pNext
*image // VkImage image
};
- VkMemoryRequirements2KHR req2 =
+ VkMemoryRequirements2 req2 =
{
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR, // VkStructureType sType
next, // void* pNext
{0, 0, 0} // VkMemoryRequirements memoryRequirements
};
- vk.getImageMemoryRequirements2KHR(device, &info, &req2);
+ vk.getImageMemoryRequirements2(device, &info, &req2);
return req2.memoryRequirements;
}
{
const deUint32 invalidVkBool32 = static_cast<deUint32>(~0);
- VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, // VkStructureType sType
DE_NULL, // void* pNext
{
const deUint32 invalidVkBool32 = static_cast<deUint32>(~0);
- VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ VkMemoryDedicatedRequirements dedicatedRequirements =
{
VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR, // VkStructureType sType
DE_NULL, // void* pNext
for (deUint32 planeNdx = 0; planeNdx < (deUint32)getPlaneCount(format); planeNdx++)
{
const VkImageAspectFlagBits aspect = getPlaneAspect(planeNdx);
- const VkImagePlaneMemoryRequirementsInfoKHR aspectInfo =
+ const VkImagePlaneMemoryRequirementsInfo aspectInfo =
{
VK_STRUCTURE_TYPE_IMAGE_PLANE_MEMORY_REQUIREMENTS_INFO_KHR,
DE_NULL,
aspect
};
- const VkImageMemoryRequirementsInfo2KHR info =
+ const VkImageMemoryRequirementsInfo2 info =
{
VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
(actualCreateFlags & VK_IMAGE_CREATE_DISJOINT_BIT_KHR) == 0 ? DE_NULL : &aspectInfo,
*image
};
- VkMemoryRequirements2KHR requirements =
+ VkMemoryRequirements2 requirements =
{
VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
DE_NULL,
{ 0u, 0u, 0u }
};
- vk.getImageMemoryRequirements2KHR(device, &info, &requirements);
+ vk.getImageMemoryRequirements2(device, &info, &requirements);
log << TestLog::Message << "Aspect: " << getImageAspectFlagsStr(aspect) << ", Requirements: " << requirements << TestLog::EndMessage;
const InstanceInterface& instance = m_context.getInstanceInterface();
const VkPhysicalDevice physicalDevice = m_context.getPhysicalDevice();
- VkPhysicalDeviceMultiviewPropertiesKHR multiviewProperties =
+ VkPhysicalDeviceMultiviewProperties multiviewProperties =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, // VkStructureType sType;
DE_NULL, // void* pNext;
&queuePriorities //const float* pQueuePriorities;
};
- VkPhysicalDeviceMultiviewFeaturesKHR multiviewFeatures =
+ VkPhysicalDeviceMultiviewFeatures multiviewFeatures =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES_KHR, // VkStructureType sType;
DE_NULL, // void* pNext;
if (TEST_TYPE_VIEW_INDEX_IN_TESELLATION == m_parameters.viewIndex && !multiviewFeatures.multiviewTessellationShader)
TCU_THROW(NotSupportedError, "Tessellation shader is not supported");
- VkPhysicalDeviceMultiviewPropertiesKHR multiviewProperties =
+ VkPhysicalDeviceMultiviewProperties multiviewProperties =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_PROPERTIES_KHR, //VkStructureType sType;
DE_NULL, //void* pNext;
};
vector <VkSubpassDescription> subpassDescriptions (subpassCount, subpassDescription);
- const VkRenderPassMultiviewCreateInfoKHR renderPassMultiviewInfo =
+ const VkRenderPassMultiviewCreateInfo renderPassMultiviewInfo =
{
VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
};
vector <VkSubpassDescription> subpassDescriptions (subpassCount, subpassDescription);
- const VkRenderPassMultiviewCreateInfoKHR renderPassMultiviewInfo =
+ const VkRenderPassMultiviewCreateInfo renderPassMultiviewInfo =
{
VK_STRUCTURE_TYPE_RENDER_PASS_MULTIVIEW_CREATE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
}
// Check if the protected memory can be enabled on the physical device.
- vk::VkPhysicalDeviceProtectedMemoryFeaturesKHR protectedFeature =
+ vk::VkPhysicalDeviceProtectedMemoryFeatures protectedFeature =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES_KHR, // sType
- DE_NULL, // pNext
- VK_FALSE // protectedMemory
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, // sType
+ DE_NULL, // pNext
+ VK_FALSE // protectedMemory
};
vk::VkPhysicalDeviceFeatures features;
deMemset(&features, 0, sizeof(vk::VkPhysicalDeviceFeatures));
- vk::VkPhysicalDeviceFeatures2KHR featuresExt =
+ vk::VkPhysicalDeviceFeatures2 featuresExt =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR, // sType
- &protectedFeature, // pNext
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, // sType
+ &protectedFeature, // pNext
features
};
- vkd.getPhysicalDeviceFeatures2KHR(physicalDevice, &featuresExt);
+ vkd.getPhysicalDeviceFeatures2(physicalDevice, &featuresExt);
if (protectedFeature.protectedMemory == VK_FALSE)
TCU_THROW(NotSupportedError, "Protected Memory feature not supported by the device");
const deUint32 queueFamilyIndex,
const deUint32 queueIdx)
{
- const vk::VkDeviceQueueInfo2KHR queueInfo =
+ const vk::VkDeviceQueueInfo2 queueInfo =
{
- vk::VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2_KHR, // sType
- DE_NULL, // pNext
- vk::VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT_KHR, // flags
- queueFamilyIndex, // queueFamilyIndex
- queueIdx, // queueIndex
+ vk::VK_STRUCTURE_TYPE_DEVICE_QUEUE_INFO_2, // sType
+ DE_NULL, // pNext
+ vk::VK_DEVICE_QUEUE_CREATE_PROTECTED_BIT, // flags
+ queueFamilyIndex, // queueFamilyIndex
+ queueIdx, // queueIndex
};
- vk::VkQueue queue = vk::getDeviceQueue2KHR(vk, device, &queueInfo);
+ vk::VkQueue queue = vk::getDeviceQueue2(vk, device, &queueInfo);
if (queue == DE_NULL)
TCU_THROW(TestError, "Unable to get a protected queue");
{
switch (layout)
{
- case VK_IMAGE_LAYOUT_GENERAL: return getAllMemoryReadFlags() | getAllMemoryWriteFlags();
- case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
- case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
- case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
- case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT;
- case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: return VK_ACCESS_TRANSFER_READ_BIT;
- case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT;
- case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
- case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
+ case VK_IMAGE_LAYOUT_GENERAL: return getAllMemoryReadFlags() | getAllMemoryWriteFlags();
+ case VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL: return VK_ACCESS_COLOR_ATTACHMENT_READ_BIT | VK_ACCESS_COLOR_ATTACHMENT_WRITE_BIT;
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT;
+ case VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT;
+ case VK_IMAGE_LAYOUT_SHADER_READ_ONLY_OPTIMAL: return VK_ACCESS_SHADER_READ_BIT;
+ case VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL: return VK_ACCESS_TRANSFER_READ_BIT;
+ case VK_IMAGE_LAYOUT_TRANSFER_DST_OPTIMAL: return VK_ACCESS_TRANSFER_WRITE_BIT;
+ case VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
+ case VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL: return VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_READ_BIT | VK_ACCESS_DEPTH_STENCIL_ATTACHMENT_WRITE_BIT | VK_ACCESS_SHADER_READ_BIT;
default:
return (VkAccessFlags)0;
}
RenderPass (const vector<Attachment>& attachments,
const vector<Subpass>& subpasses,
const vector<SubpassDependency>& dependencies,
- const vector<VkInputAttachmentAspectReferenceKHR> inputAspects = vector<VkInputAttachmentAspectReferenceKHR>())
+ const vector<VkInputAttachmentAspectReference> inputAspects = vector<VkInputAttachmentAspectReference>())
: m_attachments (attachments)
, m_subpasses (subpasses)
, m_dependencies (dependencies)
const vector<Attachment>& getAttachments (void) const { return m_attachments; }
const vector<Subpass>& getSubpasses (void) const { return m_subpasses; }
const vector<SubpassDependency>& getDependencies (void) const { return m_dependencies; }
- const vector<VkInputAttachmentAspectReferenceKHR> getInputAspects (void) const { return m_inputAspects; }
+ const vector<VkInputAttachmentAspectReference> getInputAspects (void) const { return m_inputAspects; }
private:
const vector<Attachment> m_attachments;
const vector<Subpass> m_subpasses;
const vector<SubpassDependency> m_dependencies;
- const vector<VkInputAttachmentAspectReferenceKHR> m_inputAspects;
+ const vector<VkInputAttachmentAspectReference> m_inputAspects;
};
struct TestConfig
for (size_t aspectNdx = 0; aspectNdx < renderPass.getInputAspects().size(); aspectNdx++)
{
- const VkInputAttachmentAspectReferenceKHR& inputAspect (renderPass.getInputAspects()[aspectNdx]);
+ const VkInputAttachmentAspectReference& inputAspect (renderPass.getInputAspects()[aspectNdx]);
log << TestLog::Message << "Subpass: " << inputAspect.subpass << TestLog::EndMessage;
log << TestLog::Message << "InputAttachmentIndex: " << inputAspect.inputAttachmentIndex << TestLog::EndMessage;
}
else
{
- const VkRenderPassInputAttachmentAspectCreateInfoKHR inputAspectCreateInfo =
+ const VkRenderPassInputAttachmentAspectCreateInfo inputAspectCreateInfo =
{
- VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO_KHR,
+ VK_STRUCTURE_TYPE_RENDER_PASS_INPUT_ATTACHMENT_ASPECT_CREATE_INFO,
DE_NULL,
(deUint32)renderPassInfo.getInputAspects().size(),
const size_t stencilIndex = renderInfo.getSubpassIndex();
const VkBool32 writeDepth = renderInfo.getDepthStencilAttachmentLayout()
&& *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR
+ && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
? VK_TRUE
: VK_FALSE;
const VkBool32 writeStencil = renderInfo.getDepthStencilAttachmentLayout()
&& *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
+ && *renderInfo.getDepthStencilAttachmentLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
? VK_TRUE
: VK_FALSE;
const VkPipelineDepthStencilStateCreateInfo depthStencilState =
const tcu::TextureFormat format = mapVkFormat(attachmentInfo.getFormat());
const bool isDepthFormat = tcu::hasDepthComponent(format.order);
const bool isStencilFormat = tcu::hasStencilComponent(format.order);
- const deUint32 bindingCount = (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
- && (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
+ const deUint32 bindingCount = (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
+ && (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
? 2u
: 1u;
if (isDepthFormat && isStencilFormat)
{
- if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
+ if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
{
const VkDescriptorImageInfo imageInfo =
{
}
}
- if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (inputAttachmentLayout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
const VkDescriptorImageInfo imageInfo =
{
const VkImageLayout layout = *m_renderInfo.getDepthStencilAttachmentLayout();
const VkClearAttachment attachment =
{
- (VkImageAspectFlags)((hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
- | (hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
+ (VkImageAspectFlags)((hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL ? VK_IMAGE_ASPECT_DEPTH_BIT : 0)
+ | (hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL ? VK_IMAGE_ASPECT_STENCIL_BIT : 0)),
attachmentNdx,
makeClearValueDepthStencil(depthStencilClear.getDepth(), depthStencilClear.getStencil())
};
1u, // layerCount
};
- if ((tcu::hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
- || (tcu::hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR))
+ if ((tcu::hasDepthComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
+ || (tcu::hasStencilComponent(format.order) && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL))
{
vk.cmdClearAttachments(commandBuffer, 1u, &attachment, 1u, &rect);
}
const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
const bool hasStencil = tcu::hasStencilComponent(format.order)
- && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR;
+ && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL;
const bool hasDepth = tcu::hasDepthComponent(format.order)
- && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR;
+ && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL;
vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
VkClearValue value;
{
if (tcu::hasDepthComponent(format.order)
&& layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
const size_t index = subpassNdx + 1;
const BoolOp op = boolOpFromIndex(index);
if (tcu::hasStencilComponent(format.order)
&& layout != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
+ && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
{
const size_t index = subpassNdx;
reference[x + y * targetSize.x()].setValue(1, (index % 2) == 0);
if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
&& subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
const Attachment& attachment (renderPassInfo.getAttachments()[subpass.getDepthStencilAttachment().getAttachment()]);
const tcu::TextureFormat format (mapVkFormat(attachment.getFormat()));
for (int compNdx = 0; compNdx < componentCount; compNdx++)
{
- if ((compNdx != 0 || layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
- && (compNdx != 1 || layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR))
+ if ((compNdx != 0 || layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
+ && (compNdx != 1 || layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL))
{
inputs.push_back(referenceAttachments[attachmentIndex][x + y * targetSize.x()].getValue(compNdx));
}
if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
&& subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
vector<PixelValue>& reference = referenceAttachments[attachmentIndex];
if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
&& subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
+ && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
{
const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
const Attachment& attachment = renderPassInfo.getAttachments()[attachmentIndex];
if (isDepthFormat || isStencilFormat)
{
- if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
+ if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
{
fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp subpassInput i_depth" << attachmentNdx << ";\n";
inputAttachmentBinding++;
}
- if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
fragmentShader << "layout(input_attachment_index = " << attachmentNdx << ", set=0, binding=" << inputAttachmentBinding << ") uniform highp usubpassInput i_stencil" << attachmentNdx << ";\n";
inputAttachmentBinding++;
if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
&& subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
const size_t index = subpassNdx + 1;
const BoolOp op = boolOpFromIndex(index);
const tcu::TextureFormat format = mapVkFormat(attachment.getFormat());
const size_t componentCount = (size_t)tcu::getNumUsedChannels(format.order);
- if (layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (layout == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
inputComponentCount += 1;
- else if (layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
+ else if (layout == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
inputComponentCount += 1;
else
inputComponentCount += componentCount;
if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
&& subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
outputComponentCount++;
}
if (isDepthFormat || isStencilFormat)
{
- if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)
+ if (isDepthFormat && layout != VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)
{
fragmentShader << "\tinputs[" << inputValueNdx << "] = 1.0 == float(subpassLoad(i_depth" << attachmentNdx << ").x);\n";
inputValueNdx++;
}
- if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (isStencilFormat && layout != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
fragmentShader << "\tinputs[" << inputValueNdx << "] = 255u == subpassLoad(i_stencil" << attachmentNdx << ").x;\n";
inputValueNdx++;
if (subpass.getDepthStencilAttachment().getAttachment() != VK_ATTACHMENT_UNUSED
&& subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_STENCIL_READ_ONLY_OPTIMAL
- && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ && subpass.getDepthStencilAttachment().getImageLayout() != VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
const deUint32 attachmentIndex = subpass.getDepthStencilAttachment().getAttachment();
const size_t index = subpassNdx + attachmentIndex;
for (size_t attachmentNdx = 0; attachmentNdx < renderPassInfo.getAttachments().size(); attachmentNdx++)
{
- if (renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
- || renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR
- || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
- || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
+ || renderPassInfo.getAttachments()[attachmentNdx].getInitialLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL
+ || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
+ || renderPassInfo.getAttachments()[attachmentNdx].getFinalLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
requireDepthStencilLayout = true;
break;
for (size_t attachmentNdx = 0; attachmentNdx < subpass.getColorAttachments().size(); attachmentNdx++)
{
- if (subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
- || subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
+ || subpass.getColorAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
requireDepthStencilLayout = true;
break;
for (size_t attachmentNdx = 0; !requireDepthStencilLayout && attachmentNdx < subpass.getInputAttachments().size(); attachmentNdx++)
{
- if (subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
- || subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
+ || subpass.getInputAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
requireDepthStencilLayout = true;
break;
for (size_t attachmentNdx = 0; !requireDepthStencilLayout && attachmentNdx < subpass.getResolveAttachments().size(); attachmentNdx++)
{
- if (subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
- || subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
+ || subpass.getResolveAttachments()[attachmentNdx].getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
requireDepthStencilLayout = true;
break;
}
}
- if (subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR
- || subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)
+ if (subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL
+ || subpass.getDepthStencilAttachment().getImageLayout() == VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)
{
requireDepthStencilLayout = true;
break;
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(format,
VK_SAMPLE_COUNT_1_BIT,
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(format,
VK_SAMPLE_COUNT_1_BIT,
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
vector<AttachmentReference>(),
vector<AttachmentReference>(),
vector<AttachmentReference>(),
- AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR),
+ AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL),
vector<deUint32>())),
vector<SubpassDependency>());
vector<AttachmentReference>(),
vector<AttachmentReference>(),
vector<AttachmentReference>(),
- AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR),
+ AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL),
vector<deUint32>())),
vector<SubpassDependency>());
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(vkFormat,
VK_SAMPLE_COUNT_1_BIT,
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(vkFormat,
VK_SAMPLE_COUNT_1_BIT,
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(vkFormat,
VK_SAMPLE_COUNT_1_BIT,
vector<deUint32>()));
subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
0u,
- vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)),
+ vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)),
vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
vector<AttachmentReference>(),
AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(vkFormat,
VK_SAMPLE_COUNT_1_BIT,
vector<deUint32>()));
subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
0u,
- vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR)),
+ vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL)),
vector<AttachmentReference>(),
vector<AttachmentReference>(),
- AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL_KHR),
+ AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_READ_ONLY_STENCIL_ATTACHMENT_OPTIMAL),
vector<deUint32>()));
deps.push_back(SubpassDependency(0, 1,
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(vkFormat,
VK_SAMPLE_COUNT_1_BIT,
vector<deUint32>()));
subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
0u,
- vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)),
+ vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)),
vector<AttachmentReference>(1, AttachmentReference(1, VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL)),
vector<AttachmentReference>(),
AttachmentReference(VK_ATTACHMENT_UNUSED, VK_IMAGE_LAYOUT_GENERAL),
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
vector<Attachment> attachments;
vector<Subpass> subpasses;
vector<SubpassDependency> deps;
- vector<VkInputAttachmentAspectReferenceKHR> inputAspects;
+ vector<VkInputAttachmentAspectReference> inputAspects;
attachments.push_back(Attachment(vkFormat,
VK_SAMPLE_COUNT_1_BIT,
vector<deUint32>()));
subpasses.push_back(Subpass(VK_PIPELINE_BIND_POINT_GRAPHICS,
0u,
- vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR)),
+ vector<AttachmentReference>(1, AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL)),
vector<AttachmentReference>(),
vector<AttachmentReference>(),
- AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL_KHR),
+ AttachmentReference(0, VK_IMAGE_LAYOUT_DEPTH_ATTACHMENT_STENCIL_READ_ONLY_OPTIMAL),
vector<deUint32>()));
deps.push_back(SubpassDependency(0, 1,
if (useInputAspect)
{
- const VkInputAttachmentAspectReferenceKHR inputAspect =
+ const VkInputAttachmentAspectReference inputAspect =
{
0u,
0u,
typedef std::map<deUint32, QueueFamilyQueuesCount> SelectedQueuesMap;
typedef std::map<deUint32, std::vector<float> > QueuePrioritiesMap;
- std::vector<VkPhysicalDeviceGroupPropertiesKHR> devGroupProperties;
+ std::vector<VkPhysicalDeviceGroupProperties> devGroupProperties;
std::vector<const char*> deviceExtensions;
- VkDeviceGroupDeviceCreateInfoKHR deviceGroupInfo =
+ VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
DE_NULL, //pNext
{
const std::vector<std::string> requiredExtensions(1, "VK_KHR_device_group_creation");
m_deviceGroupInstance = createInstanceWithExtensions(m_context.getPlatformInterface(), m_context.getUsedApiVersion(), requiredExtensions);
- devGroupProperties = enumeratePhysicalDeviceGroupsKHR(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
+ devGroupProperties = enumeratePhysicalDeviceGroups(m_context.getInstanceInterface(), m_deviceGroupInstance.get());
m_numPhysicalDevices = devGroupProperties[m_deviceGroupIdx].physicalDeviceCount;
m_physicalDevices.clear();
)
};
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
const VkSparseBufferMemoryBindInfo sparseBufferBindInfo = makeSparseBufferMemoryBindInfo(*sparseBuffer, numSparseBinds, &sparseMemoryBinds[0]);
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
const VkSparseBufferMemoryBindInfo sparseBufferBindInfo = makeSparseBufferMemoryBindInfo(*sparseBuffer, static_cast<deUint32>(sparseMemoryBinds.size()), &sparseMemoryBinds[0]);
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
&sparseAllocation.memoryBinds[0], // const VkSparseMemoryBind* pBinds;
};
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
imageWriteMipTailBinds.push_back(imageWriteMipTailMemoryBind);
}
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
const VkSparseImageOpaqueMemoryBindInfo opaqueBindInfo = makeSparseImageOpaqueMemoryBindInfo(*imageSparse, numSparseBinds, &sparseMemoryBinds[0]);
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
}
}
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
}
}
- const VkDeviceGroupBindSparseInfoKHR devGroupBindSparseInfo =
+ const VkDeviceGroupBindSparseInfo devGroupBindSparseInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_BIND_SPARSE_INFO_KHR, //VkStructureType sType;
DE_NULL, //const void* pNext;
const deUint32 deviceMask = 1 << physicalDeviceID;
std::vector<deUint32> deviceIndices (waitSemaphoreCount, physicalDeviceID);
- VkDeviceGroupSubmitInfoKHR deviceGroupSubmitInfo =
+ VkDeviceGroupSubmitInfo deviceGroupSubmitInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_SUBMIT_INFO_KHR, //VkStructureType sType
DE_NULL, // const void* pNext
return enabledDeviceFeatures;
}
-VkPhysicalDevice16BitStorageFeaturesKHR querySupported16BitStorageFeatures (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
+VkPhysicalDevice16BitStorageFeatures querySupported16BitStorageFeatures (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
{
- VkPhysicalDevice16BitStorageFeaturesKHR extensionFeatures =
+ VkPhysicalDevice16BitStorageFeatures extensionFeatures =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES_KHR, // sType
DE_NULL, // pNext
// Call the getter only if supported. Otherwise above "zero" defaults are used
if (de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2"))
{
- vki.getPhysicalDeviceFeatures2KHR(device, &features);
+ vki.getPhysicalDeviceFeatures2(device, &features);
}
return extensionFeatures;
}
-VkPhysicalDeviceVariablePointerFeaturesKHR querySupportedVariablePointersFeatures (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
+VkPhysicalDeviceVariablePointerFeatures querySupportedVariablePointersFeatures (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions)
{
- VkPhysicalDeviceVariablePointerFeaturesKHR extensionFeatures =
+ VkPhysicalDeviceVariablePointerFeatures extensionFeatures =
{
VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTER_FEATURES_KHR, // sType
DE_NULL, // pNext
false, // variablePointers
};
- VkPhysicalDeviceFeatures2KHR features;
+ VkPhysicalDeviceFeatures2 features;
deMemset(&features, 0, sizeof(features));
features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
features.pNext = &extensionFeatures;
// Call the getter only if supported. Otherwise above "zero" defaults are used
if (de::contains(instanceExtensions.begin(), instanceExtensions.end(), "VK_KHR_get_physical_device_properties2"))
{
- vki.getPhysicalDeviceFeatures2KHR(device, &features);
+ vki.getPhysicalDeviceFeatures2(device, &features);
}
return extensionFeatures;
bool is16BitStorageFeaturesSupported (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, Extension16BitStorageFeatures toCheck)
{
- VkPhysicalDevice16BitStorageFeaturesKHR extensionFeatures = querySupported16BitStorageFeatures(vki, device, instanceExtensions);
+ VkPhysicalDevice16BitStorageFeatures extensionFeatures = querySupported16BitStorageFeatures(vki, device, instanceExtensions);
if ((toCheck & EXT16BITSTORAGEFEATURES_UNIFORM_BUFFER_BLOCK) != 0 && extensionFeatures.storageBuffer16BitAccess == VK_FALSE)
return false;
bool isVariablePointersFeaturesSupported (const InstanceInterface& vki, VkPhysicalDevice device, const std::vector<std::string>& instanceExtensions, ExtensionVariablePointersFeatures toCheck)
{
- VkPhysicalDeviceVariablePointerFeaturesKHR extensionFeatures = querySupportedVariablePointersFeatures(vki, device, instanceExtensions);
+ VkPhysicalDeviceVariablePointerFeatures extensionFeatures = querySupportedVariablePointersFeatures(vki, device, instanceExtensions);
if ((toCheck & EXTVARIABLEPOINTERSFEATURES_VARIABLE_POINTERS_STORAGEBUFFER) != 0 && extensionFeatures.variablePointersStorageBuffer == VK_FALSE)
return false;
std::vector<const char*> extensions (requiredExtensions.size());
void* pExtension = DE_NULL;
const VkPhysicalDeviceFeatures deviceFeatures = getPhysicalDeviceFeatures(vki, physicalDevice);
- VkPhysicalDevice16BitStorageFeaturesKHR ext16BitStorageFeatures;
- VkPhysicalDeviceVariablePointerFeaturesKHR extVariablePointerFeatures;
+ VkPhysicalDevice16BitStorageFeatures ext16BitStorageFeatures;
+ VkPhysicalDeviceVariablePointerFeatures extVariablePointerFeatures;
for (deUint32 extNdx = 0; extNdx < requiredExtensions.size(); ++extNdx)
{
subgroupProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
subgroupProperties.pNext = DE_NULL;
- VkPhysicalDeviceProperties2KHR properties;
- properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+ VkPhysicalDeviceProperties2 properties;
+ properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
properties.pNext = &subgroupProperties;
- context.getInstanceInterface().getPhysicalDeviceProperties2KHR(context.getPhysicalDevice(), &properties);
+ context.getInstanceInterface().getPhysicalDeviceProperties2(context.getPhysicalDevice(), &properties);
return subgroupProperties.subgroupSize;
}
subgroupProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
subgroupProperties.pNext = DE_NULL;
- VkPhysicalDeviceProperties2KHR properties;
- properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+ VkPhysicalDeviceProperties2 properties;
+ properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
properties.pNext = &subgroupProperties;
- context.getInstanceInterface().getPhysicalDeviceProperties2KHR(context.getPhysicalDevice(), &properties);
+ context.getInstanceInterface().getPhysicalDeviceProperties2(context.getPhysicalDevice(), &properties);
return (stage & subgroupProperties.supportedStages) ? true : false;
}
subgroupProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_PROPERTIES;
subgroupProperties.pNext = DE_NULL;
- VkPhysicalDeviceProperties2KHR properties;
- properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2_KHR;
+ VkPhysicalDeviceProperties2 properties;
+ properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
properties.pNext = &subgroupProperties;
- context.getInstanceInterface().getPhysicalDeviceProperties2KHR(context.getPhysicalDevice(), &properties);
+ context.getInstanceInterface().getPhysicalDeviceProperties2(context.getPhysicalDevice(), &properties);
return (bit & subgroupProperties.supportedOperations) ? true : false;
}
TestConfig (const ResourceDescription& resource_,
OperationName writeOp_,
OperationName readOp_,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleType_,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR semaphoreHandleType_,
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType_,
+ vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreHandleType_,
bool dedicated_)
: resource (resource_)
, writeOp (writeOp_)
const ResourceDescription resource;
const OperationName writeOp;
const OperationName readOp;
- const vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleType;
- const vk::VkExternalSemaphoreHandleTypeFlagBitsKHR semaphoreHandleType;
+ const vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType;
+ const vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreHandleType;
const bool dedicated;
};
DeviceId getDeviceId (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice physicalDevice)
{
- vk::VkPhysicalDeviceIDPropertiesKHR propertiesId;
+ vk::VkPhysicalDeviceIDProperties propertiesId;
vk::VkPhysicalDeviceProperties2 properties;
deMemset(&properties, 0, sizeof(properties));
deMemset(&propertiesId, 0, sizeof(propertiesId));
- propertiesId.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR;
+ propertiesId.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES;
properties.sType = vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
properties.pNext = &propertiesId;
vk::Move<vk::VkDevice> createDevice (const vk::InstanceInterface& vki,
vk::VkPhysicalDevice physicalDevice,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleType,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR semaphoreHandleType,
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreHandleType,
bool dedicated,
bool khrMemReqSupported)
{
extensions.push_back("VK_KHR_external_semaphore");
extensions.push_back("VK_KHR_external_memory");
- if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR
- || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT
+ || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
extensions.push_back("VK_KHR_external_semaphore_fd");
extensions.push_back("VK_KHR_external_memory_fd");
}
- if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR
- || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT
+ || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || semaphoreHandleType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
extensions.push_back("VK_KHR_external_semaphore_win32");
extensions.push_back("VK_KHR_external_memory_win32");
de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkBuffer buffer,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32& exportedMemoryTypeIndex,
bool dedicated,
bool getMemReq2Supported)
if (getMemReq2Supported)
{
- const vk::VkBufferMemoryRequirementsInfo2KHR requirementInfo =
+ const vk::VkBufferMemoryRequirementsInfo2 requirementInfo =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
buffer
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u, }
};
- vkd.getBufferMemoryRequirements2KHR(device, &requirementInfo, &requirements);
+ vkd.getBufferMemoryRequirements2(device, &requirementInfo, &requirements);
if (!dedicated && dedicatedRequirements.requiresDedicatedAllocation)
TCU_THROW(NotSupportedError, "Memory requires dedicated allocation");
de::MovePtr<vk::Allocation> allocateAndBindMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkImage image,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32& exportedMemoryTypeIndex,
bool dedicated,
bool getMemReq2Supported)
if (getMemReq2Supported)
{
- const vk::VkImageMemoryRequirementsInfo2KHR requirementInfo =
+ const vk::VkImageMemoryRequirementsInfo2 requirementInfo =
{
- vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
image
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u, }
};
- vkd.getImageMemoryRequirements2KHR(device, &requirementInfo, &requirements);
+ vkd.getImageMemoryRequirements2(device, &requirementInfo, &requirements);
if (!dedicated && dedicatedRequirements.requiresDedicatedAllocation)
TCU_THROW(NotSupportedError, "Memory requires dedicated allocation");
const std::vector<deUint32>& queueFamilyIndices,
const OperationSupport& readOp,
const OperationSupport& writeOp,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32& exportedMemoryTypeIndex,
bool dedicated,
bool getMemReq2Supported)
0u,
1u
};
- const vk::VkExternalMemoryImageCreateInfoKHR externalInfo =
+ const vk::VkExternalMemoryImageCreateInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkImageCreateInfo createInfo =
{
const vk::VkDeviceSize offset = 0u;
const vk::VkDeviceSize size = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
const vk::VkBufferUsageFlags usage = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
- const vk:: VkExternalMemoryBufferCreateInfoKHR externalInfo =
+ const vk:: VkExternalMemoryBufferCreateInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkBufferCreateInfo createInfo =
{
vk::VkDevice device,
vk::VkBuffer buffer,
NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 exportedMemoryTypeIndex,
bool dedicated)
{
vk::VkDevice device,
vk::VkImage image,
NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 exportedMemoryTypeIndex,
bool dedicated)
{
const OperationSupport& readOp,
const OperationSupport& writeOp,
NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 exportedMemoryTypeIndex,
bool dedicated)
{
0u,
1u
};
- const vk:: VkExternalMemoryImageCreateInfoKHR externalInfo =
+ const vk:: VkExternalMemoryImageCreateInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkImageCreateInfo createInfo =
{
const vk::VkDeviceSize offset = 0u;
const vk::VkDeviceSize size = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
const vk::VkBufferUsageFlags usage = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
- const vk:: VkExternalMemoryBufferCreateInfoKHR externalInfo =
+ const vk:: VkExternalMemoryBufferCreateInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkBufferCreateInfo createInfo =
{
readSync.imageLayout,
writeQueueFamilyIndex,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
resource.getImage().handle,
resource.getImage().subresourceRange
dstAccessMask,
writeQueueFamilyIndex,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
resource.getBuffer().handle,
0u,
writeSync.imageLayout,
readSync.imageLayout,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
readQueueFamilyIndex,
resource.getImage().handle,
srcAccessMask,
dstAccessMask,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
readQueueFamilyIndex,
resource.getBuffer().handle,
const vk::Unique<vk::VkDevice> m_deviceB;
const vk::DeviceDriver m_vkdB;
- const vk::VkExternalSemaphoreHandleTypeFlagBitsKHR m_semaphoreHandleType;
- const vk::VkExternalMemoryHandleTypeFlagBitsKHR m_memoryHandleType;
+ const vk::VkExternalSemaphoreHandleTypeFlagBits m_semaphoreHandleType;
+ const vk::VkExternalMemoryHandleTypeFlagBits m_memoryHandleType;
// \todo Should this be moved to the group same way as in the other tests?
PipelineCacheData m_pipelineCacheData;
// Check resource support
if (m_config.resource.type == RESOURCE_TYPE_IMAGE)
{
- const vk::VkPhysicalDeviceExternalImageFormatInfoKHR externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
m_memoryHandleType
};
m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
0u
};
- vk::VkExternalImageFormatPropertiesKHR externalProperties =
+ vk::VkExternalImageFormatProperties externalProperties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_IMAGE_FORMAT_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u }
};
// \todo How to log this nicely?
log << TestLog::Message << "External image format properties: " << imageFormatInfo << "\n"<< externalProperties << TestLog::EndMessage;
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Exporting image resource not supported");
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Importing image resource not supported");
- if (!m_config.dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ if (!m_config.dedicated && (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0)
{
TCU_THROW(NotSupportedError, "Handle requires dedicated allocation, but test uses suballocated memory");
}
}
else
{
- const vk::VkPhysicalDeviceExternalBufferInfoKHR info =
+ const vk::VkPhysicalDeviceExternalBufferInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
DE_NULL,
0u,
m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
m_memoryHandleType
};
- vk::VkExternalBufferPropertiesKHR properties =
+ vk::VkExternalBufferProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u}
};
- m_vkiA.getPhysicalDeviceExternalBufferPropertiesKHR(m_physicalDeviceA, &info, &properties);
+ m_vkiA.getPhysicalDeviceExternalBufferProperties(m_physicalDeviceA, &info, &properties);
log << TestLog::Message << "External buffer properties: " << info << "\n" << properties << TestLog::EndMessage;
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT_KHR) == 0
- || (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_EXPORTABLE_BIT) == 0
+ || (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Exporting and importing memory type not supported");
- if (!m_config.dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR) != 0)
+ if (!m_config.dedicated && (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT) != 0)
{
TCU_THROW(NotSupportedError, "Handle requires dedicated allocation, but test uses suballocated memory");
}
// Check semaphore support
{
- const vk::VkPhysicalDeviceExternalSemaphoreInfoKHR info =
+ const vk::VkPhysicalDeviceExternalSemaphoreInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_SEMAPHORE_INFO,
DE_NULL,
m_semaphoreHandleType
};
- vk::VkExternalSemaphorePropertiesKHR properties;
+ vk::VkExternalSemaphoreProperties properties;
- m_vkiA.getPhysicalDeviceExternalSemaphorePropertiesKHR(m_physicalDeviceA, &info, &properties);
+ m_vkiA.getPhysicalDeviceExternalSemaphoreProperties(m_physicalDeviceA, &info, &properties);
log << TestLog::Message << info << "\n" << properties << TestLog::EndMessage;
- if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT_KHR) == 0
- || (properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_EXPORTABLE_BIT) == 0
+ || (properties.externalSemaphoreFeatures & vk::VK_EXTERNAL_SEMAPHORE_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Exporting and importing semaphore type not supported");
}
}
{
const struct
{
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryType;
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR semaphoreType;
+ vk::VkExternalMemoryHandleTypeFlagBits memoryType;
+ vk::VkExternalSemaphoreHandleTypeFlagBits semaphoreType;
const char* nameSuffix;
} cases[] =
{
{
- vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
- vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+ vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT,
"_fd"
},
{
- vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR,
- vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR,
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT,
+ vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT,
"_fence_fd"
},
{
- vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
- vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
"_win32_kmt"
},
{
- vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
- vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR,
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT,
+ vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT,
"_win32"
},
};
TestConfig (const ResourceDescription& resource_,
OperationName writeOp_,
OperationName readOp_,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleTypeBuffer_,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleTypeImage_)
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeBuffer_,
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeImage_)
: resource (resource_)
, writeOp (writeOp_)
, readOp (readOp_)
const ResourceDescription resource;
const OperationName writeOp;
const OperationName readOp;
- const vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleTypeBuffer;
- const vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleTypeImage;
+ const vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeBuffer;
+ const vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeImage;
};
bool checkQueueFlags (vk::VkQueueFlags availableFlags, const vk::VkQueueFlags neededFlags)
vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
NativeHandle& handle,
bool requiresDedicated,
vk::VkBuffer buffer,
vk::VkImage image)
{
- const vk::VkMemoryDedicatedAllocateInfoKHR dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
DE_NULL,
image,
buffer,
vk::VkDevice device,
vk::VkBuffer buffer,
NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
- const vk::VkBufferMemoryRequirementsInfo2KHR requirementsInfo =
+ const vk::VkBufferMemoryRequirementsInfo2 requirementsInfo =
{
- vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_BUFFER_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
buffer,
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE,
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u, },
};
- vkd.getBufferMemoryRequirements2KHR(device, &requirementsInfo, &requirements);
+ vkd.getBufferMemoryRequirements2(device, &requirementsInfo, &requirements);
vk::Move<vk::VkDeviceMemory> memory = importMemory(vkd, device, requirements.memoryRequirements, externalType, nativeHandle, !!dedicatedRequirements.requiresDedicatedAllocation, buffer, DE_NULL);
VK_CHECK(vkd.bindBufferMemory(device, buffer, *memory, 0u));
vk::VkDevice device,
vk::VkImage image,
NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
- const vk::VkImageMemoryRequirementsInfo2KHR requirementsInfo =
+ const vk::VkImageMemoryRequirementsInfo2 requirementsInfo =
{
- vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2_KHR,
+ vk::VK_STRUCTURE_TYPE_IMAGE_MEMORY_REQUIREMENTS_INFO_2,
DE_NULL,
image,
};
- vk::VkMemoryDedicatedRequirementsKHR dedicatedRequirements =
+ vk::VkMemoryDedicatedRequirements dedicatedRequirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_REQUIREMENTS,
DE_NULL,
VK_FALSE,
VK_FALSE,
};
- vk::VkMemoryRequirements2KHR requirements =
+ vk::VkMemoryRequirements2 requirements =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_REQUIREMENTS_2,
&dedicatedRequirements,
{ 0u, 0u, 0u, },
};
- vkd.getImageMemoryRequirements2KHR(device, &requirementsInfo, &requirements);
+ vkd.getImageMemoryRequirements2(device, &requirementsInfo, &requirements);
vk::Move<vk::VkDeviceMemory> memory = importMemory(vkd, device, requirements.memoryRequirements, externalType, nativeHandle, !!dedicatedRequirements.requiresDedicatedAllocation, DE_NULL, image);
VK_CHECK(vkd.bindImageMemory(device, image, *memory, 0u));
const OperationSupport& readOp,
const OperationSupport& writeOp,
NativeHandle& nativeHandle,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
if (resourceDesc.type == RESOURCE_TYPE_IMAGE)
{
0u,
1u
};
- const vk::VkExternalMemoryImageCreateInfoKHR externalInfo =
+ const vk::VkExternalMemoryImageCreateInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkImageCreateInfo createInfo =
{
const vk::VkDeviceSize offset = 0u;
const vk::VkDeviceSize size = static_cast<vk::VkDeviceSize>(resourceDesc.size.x());
const vk::VkBufferUsageFlags usage = readOp.getResourceUsageFlags() | writeOp.getResourceUsageFlags();
- const vk::VkExternalMemoryBufferCreateInfoKHR externalInfo =
+ const vk::VkExternalMemoryBufferCreateInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkBufferCreateInfo createInfo =
{
readSync.imageLayout,
writeQueueFamilyIndex,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
resource.getImage().handle,
resource.getImage().subresourceRange
dstAccessMask,
writeQueueFamilyIndex,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
resource.getBuffer().handle,
0u,
writeSync.imageLayout,
readSync.imageLayout,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
readQueueFamilyIndex,
resource.getImage().handle,
srcAccessMask,
dstAccessMask,
- VK_QUEUE_FAMILY_EXTERNAL_KHR,
+ VK_QUEUE_FAMILY_EXTERNAL,
readQueueFamilyIndex,
resource.getBuffer().handle,
#if (DE_OS == DE_OS_WIN32)
DX11Operation (const ResourceDescription& resourceDesc,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleType,
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType,
ID3D11Device* pDevice,
ID3D11DeviceContext* pContext,
LPD3DX11COMPILEFROMMEMORY fnD3DX11CompileFromMemory,
{
HRESULT hr;
- if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR ||
- memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR)
+ if (memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT ||
+ memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT)
m_isMemNtHandle = true;
else
#if (DE_OS == DE_OS_WIN32)
HRESULT hr;
- vk::VkPhysicalDeviceIDPropertiesKHR propertiesId = { vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES_KHR };
- vk::VkPhysicalDeviceProperties2KHR properties = { vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
+ vk::VkPhysicalDeviceIDProperties propertiesId = { vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_ID_PROPERTIES };
+ vk::VkPhysicalDeviceProperties2 properties = { vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2 };
properties.pNext = &propertiesId;
- vki.getPhysicalDeviceProperties2KHR(physicalDevice, &properties);
+ vki.getPhysicalDeviceProperties2(physicalDevice, &properties);
if (!propertiesId.deviceLUIDValid)
TCU_FAIL("Physical device deviceLUIDValid is not valid");
#endif
- virtual de::MovePtr<DX11Operation> build (const ResourceDescription& resourceDesc, vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleType) const
+ virtual de::MovePtr<DX11Operation> build (const ResourceDescription& resourceDesc, vk::VkExternalMemoryHandleTypeFlagBits memoryHandleType) const
{
#if (DE_OS == DE_OS_WIN32)
return de::MovePtr<DX11Operation>(new DX11Operation(resourceDesc, memoryHandleType, m_pDevice, m_pContext, m_fnD3DX11CompileFromMemory, m_fnD3DCompile));
const de::UniquePtr<DX11OperationSupport> m_supportDX11;
- const vk::VkExternalMemoryHandleTypeFlagBitsKHR m_memoryHandleType;
+ const vk::VkExternalMemoryHandleTypeFlagBits m_memoryHandleType;
// \todo Should this be moved to the group same way as in the other tests?
PipelineCacheData m_pipelineCacheData;
// Check resource support
if (m_config.resource.type == RESOURCE_TYPE_IMAGE)
{
- if (m_memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR && !IsWindows8OrGreater())
+ if (m_memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT && !IsWindows8OrGreater())
TCU_THROW(NotSupportedError, "Memory handle type not supported by this OS");
- const vk::VkPhysicalDeviceExternalImageFormatInfoKHR externalInfo =
+ const vk::VkPhysicalDeviceExternalImageFormatInfo externalInfo =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
m_memoryHandleType
};
- const vk::VkPhysicalDeviceImageFormatInfo2KHR imageFormatInfo =
+ const vk::VkPhysicalDeviceImageFormatInfo2 imageFormatInfo =
{
vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGE_FORMAT_INFO_2,
&externalInfo,
m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
0u
};
- vk::VkExternalImageFormatPropertiesKHR externalProperties =
+ vk::VkExternalImageFormatProperties externalProperties =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_IMAGE_FORMAT_INFO,
DE_NULL,
{ 0u, 0u, 0u }
};
- vk::VkImageFormatProperties2KHR formatProperties =
+ vk::VkImageFormatProperties2 formatProperties =
{
vk::VK_STRUCTURE_TYPE_IMAGE_FORMAT_PROPERTIES_2,
&externalProperties,
0u,
}
};
- VK_CHECK(m_vki.getPhysicalDeviceImageFormatProperties2KHR(m_physicalDevice, &imageFormatInfo, &formatProperties));
+ VK_CHECK(m_vki.getPhysicalDeviceImageFormatProperties2(m_physicalDevice, &imageFormatInfo, &formatProperties));
// \todo How to log this nicely?
log << TestLog::Message << "External image format properties: " << imageFormatInfo << "\n"<< externalProperties << TestLog::EndMessage;
- if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Importing image resource not supported");
- if (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR)
+ if (externalProperties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT)
m_useDedicatedAllocation = true;
}
else
{
- if (m_memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR && !IsWindows8OrGreater())
+ if (m_memoryHandleType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT && !IsWindows8OrGreater())
TCU_THROW(NotSupportedError, "Memory handle type not supported by this OS");
- const vk::VkPhysicalDeviceExternalBufferInfoKHR info =
+ const vk::VkPhysicalDeviceExternalBufferInfo info =
{
- vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXTERNAL_BUFFER_INFO,
DE_NULL,
0u,
m_supportReadOp->getResourceUsageFlags() | m_supportWriteOp->getResourceUsageFlags(),
m_memoryHandleType
};
- vk::VkExternalBufferPropertiesKHR properties =
+ vk::VkExternalBufferProperties properties =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_BUFFER_PROPERTIES,
DE_NULL,
{ 0u, 0u, 0u}
};
- m_vki.getPhysicalDeviceExternalBufferPropertiesKHR(m_physicalDevice, &info, &properties);
+ m_vki.getPhysicalDeviceExternalBufferProperties(m_physicalDevice, &info, &properties);
log << TestLog::Message << "External buffer properties: " << info << "\n" << properties << TestLog::EndMessage;
- if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT_KHR) == 0)
+ if ((properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_IMPORTABLE_BIT) == 0)
TCU_THROW(NotSupportedError, "Importing memory type not supported");
- if (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT_KHR)
+ if (properties.externalMemoryProperties.externalMemoryFeatures & vk::VK_EXTERNAL_MEMORY_FEATURE_DEDICATED_ONLY_BIT)
m_useDedicatedAllocation = true;
}
#else
{
const struct
{
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleTypeBuffer;
- vk::VkExternalMemoryHandleTypeFlagBitsKHR memoryHandleTypeImage;
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeBuffer;
+ vk::VkExternalMemoryHandleTypeFlagBits memoryHandleTypeImage;
const char* nameSuffix;
} cases[] =
{
{
- (vk::VkExternalMemoryHandleTypeFlagBitsKHR)0u, // DX11 doesn't support buffers with an NT handle
- vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR,
+ (vk::VkExternalMemoryHandleTypeFlagBits)0u, // DX11 doesn't support buffers with an NT handle
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT,
"_nt"
},
{
- vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR,
- vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR,
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT,
+ vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT,
"_kmt"
},
};
VK_FALSE, // VkBool32 primitiveRestartEnable;
};
- const VkPipelineTessellationDomainOriginStateCreateInfoKHR tessellationDomainOriginStateInfo =
+ const VkPipelineTessellationDomainOriginStateCreateInfo tessellationDomainOriginStateInfo =
{
- VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO_KHR,
+ VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_DOMAIN_ORIGIN_STATE_CREATE_INFO,
DE_NULL,
- (!m_tessellationDomainOrigin ? VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR : *m_tessellationDomainOrigin)
+ (!m_tessellationDomainOrigin ? VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT : *m_tessellationDomainOrigin)
};
const VkPipelineTessellationStateCreateInfo pipelineTessellationStateInfo =
{
, m_patchControlPoints (1u)
, m_blendEnable (false)
, m_primitiveTopology (vk::VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST)
- , m_tessellationDomainOrigin (tcu::nothing<vk::VkTessellationDomainOriginKHR>()) {}
+ , m_tessellationDomainOrigin (tcu::nothing<vk::VkTessellationDomainOrigin>()) {}
GraphicsPipelineBuilder& setRenderSize (const tcu::IVec2& size) { m_renderSize = size; return *this; }
GraphicsPipelineBuilder& setShader (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkShaderStageFlagBits stage, const vk::ProgramBinary& binary, const vk::VkSpecializationInfo* specInfo);
//! Basic vertex input configuration (uses biding 0, location 0, etc.)
GraphicsPipelineBuilder& setVertexInputSingleAttribute (const vk::VkFormat vertexFormat, const deUint32 stride);
- //! If tessellation domain origin is set, pipeline requires VK_KHR_maintenance2
- GraphicsPipelineBuilder& setTessellationDomainOrigin (const vk::VkTessellationDomainOriginKHR domainOrigin) { return setTessellationDomainOrigin(tcu::just(domainOrigin)); }
- GraphicsPipelineBuilder& setTessellationDomainOrigin (const tcu::Maybe<vk::VkTessellationDomainOriginKHR>& domainOrigin) { m_tessellationDomainOrigin = domainOrigin; return *this; }
+ //! If tessellation domain origin is set, pipeline requires VK__maintenance2
+ GraphicsPipelineBuilder& setTessellationDomainOrigin (const vk::VkTessellationDomainOrigin domainOrigin) { return setTessellationDomainOrigin(tcu::just(domainOrigin)); }
+ GraphicsPipelineBuilder& setTessellationDomainOrigin (const tcu::Maybe<vk::VkTessellationDomainOrigin>& domainOrigin) { m_tessellationDomainOrigin = domainOrigin; return *this; }
vk::Move<vk::VkPipeline> build (const vk::DeviceInterface& vk, const vk::VkDevice device, const vk::VkPipelineLayout pipelineLayout, const vk::VkRenderPass renderPass);
deUint32 m_patchControlPoints;
bool m_blendEnable;
vk::VkPrimitiveTopology m_primitiveTopology;
- tcu::Maybe<vk::VkTessellationDomainOriginKHR> m_tessellationDomainOrigin;
+ tcu::Maybe<vk::VkTessellationDomainOrigin> m_tessellationDomainOrigin;
GraphicsPipelineBuilder (const GraphicsPipelineBuilder&); // "deleted"
GraphicsPipelineBuilder& operator= (const GraphicsPipelineBuilder&);
bool verifyResultImage (tcu::TestLog& log,
const tcu::ConstPixelBufferAccess image,
const TessPrimitiveType primitiveType,
- const VkTessellationDomainOriginKHR domainOrigin,
+ const VkTessellationDomainOrigin domainOrigin,
const Winding winding,
bool yFlip,
const Winding frontFaceWinding)
{
- const bool expectVisiblePrimitive = ((frontFaceWinding == winding) == (domainOrigin == VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR)) != yFlip;
+ const bool expectVisiblePrimitive = ((frontFaceWinding == winding) == (domainOrigin == VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT)) != yFlip;
const int totalNumPixels = image.getWidth()*image.getHeight();
return true;
}
-typedef tcu::Maybe<VkTessellationDomainOriginKHR> MaybeDomainOrigin;
+typedef tcu::Maybe<VkTessellationDomainOrigin> MaybeDomainOrigin;
class WindingTest : public TestCase
{
success = verifyResultImage(log,
imagePixelAccess,
m_primitiveType,
- !m_domainOrigin ? VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR : *m_domainOrigin,
+ !m_domainOrigin ? VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT : *m_domainOrigin,
m_winding,
m_yFlip,
frontFaceWinding) && success;
return new WindingTestInstance(context, m_primitiveType, m_domainOrigin, m_winding, m_yFlip);
}
-void populateWindingGroup (tcu::TestCaseGroup* group, tcu::Maybe<VkTessellationDomainOriginKHR> domainOrigin)
+void populateWindingGroup (tcu::TestCaseGroup* group, tcu::Maybe<VkTessellationDomainOrigin> domainOrigin)
{
static const TessPrimitiveType primitivesNoIsolines[] =
{
{
de::MovePtr<tcu::TestCaseGroup> group (new tcu::TestCaseGroup(testCtx, "winding", "Test the cw and ccw input layout qualifiers"));
- addTestGroup(group.get(), "default_domain", "No tessellation domain specified", populateWindingGroup, tcu::nothing<VkTessellationDomainOriginKHR>());
- addTestGroup(group.get(), "lower_left_domain", "Lower left tessellation domain", populateWindingGroup, tcu::just(VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT_KHR));
- addTestGroup(group.get(), "upper_left_domain", "Upper left tessellation domain", populateWindingGroup, tcu::just(VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT_KHR));
+ addTestGroup(group.get(), "default_domain", "No tessellation domain specified", populateWindingGroup, tcu::nothing<VkTessellationDomainOrigin>());
+ addTestGroup(group.get(), "lower_left_domain", "Lower left tessellation domain", populateWindingGroup, tcu::just(VK_TESSELLATION_DOMAIN_ORIGIN_LOWER_LEFT));
+ addTestGroup(group.get(), "upper_left_domain", "Upper left tessellation domain", populateWindingGroup, tcu::just(VK_TESSELLATION_DOMAIN_ORIGIN_UPPER_LEFT));
return group.release();
}
return m_fd;
}
-const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR type)
+const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBits type)
{
switch (type)
{
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
return "opaque_fd";
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
return "opaque_win32";
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return "opaque_win32_kmt";
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_D3D12_FENCE_BIT:
return "d3d12_fenc";
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
return "sync_fd";
default:
}
}
-const char* externalFenceTypeToName (vk::VkExternalFenceHandleTypeFlagBitsKHR type)
+const char* externalFenceTypeToName (vk::VkExternalFenceHandleTypeFlagBits type)
{
switch (type)
{
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
return "opaque_fd";
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
return "opaque_win32";
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return "opaque_win32_kmt";
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
return "sync_fd";
default:
}
}
-const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBitsKHR type)
+const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBits type)
{
switch (type)
{
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT:
return "opaque_fd";
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
return "opaque_win32";
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return "opaque_win32_kmt";
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_BIT:
return "d3d11_texture";
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D11_TEXTURE_KMT_BIT:
return "d3d11_texture_kmt";
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_HEAP_BIT:
return "d3d12_heap";
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_D3D12_RESOURCE_BIT:
return "d3d12_resource";
default:
}
}
-bool isSupportedPermanence (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR type,
+bool isSupportedPermanence (vk::VkExternalSemaphoreHandleTypeFlagBits type,
Permanence permanence)
{
switch (type)
{
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return permanence == PERMANENCE_PERMANENT || permanence == PERMANENCE_TEMPORARY;
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
return permanence == PERMANENCE_PERMANENT || permanence == PERMANENCE_TEMPORARY;
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
return permanence == PERMANENCE_TEMPORARY;
default:
}
}
-Transference getHandelTypeTransferences (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR type)
+Transference getHandelTypeTransferences (vk::VkExternalSemaphoreHandleTypeFlagBits type)
{
switch (type)
{
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return TRANSFERENCE_REFERENCE;
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT:
return TRANSFERENCE_REFERENCE;
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT:
return TRANSFERENCE_COPY;
default:
}
}
-bool isSupportedPermanence (vk::VkExternalFenceHandleTypeFlagBitsKHR type,
+bool isSupportedPermanence (vk::VkExternalFenceHandleTypeFlagBits type,
Permanence permanence)
{
switch (type)
{
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return permanence == PERMANENCE_PERMANENT || permanence == PERMANENCE_TEMPORARY;
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
return permanence == PERMANENCE_PERMANENT || permanence == PERMANENCE_TEMPORARY;
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
return permanence == PERMANENCE_TEMPORARY;
default:
}
}
-Transference getHandelTypeTransferences (vk::VkExternalFenceHandleTypeFlagBitsKHR type)
+Transference getHandelTypeTransferences (vk::VkExternalFenceHandleTypeFlagBits type)
{
switch (type)
{
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
return TRANSFERENCE_REFERENCE;
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT:
return TRANSFERENCE_REFERENCE;
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT:
return TRANSFERENCE_COPY;
default:
int getMemoryFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalMemoryHandleTypeFlagBits externalType)
{
const vk::VkMemoryGetFdInfoKHR info =
{
void getMemoryNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
NativeHandle& nativeHandle)
{
- if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
{
const vk::VkMemoryGetFdInfoKHR info =
{
TCU_CHECK(fd >= 0);
nativeHandle = fd;
}
- else if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ else if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
const vk::VkMemoryGetWin32HandleInfoKHR info =
{
switch (externalType)
{
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT:
nativeHandle.setWin32Handle(NativeHandle::WIN32HANDLETYPE_NT, handle);
break;
- case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
nativeHandle.setWin32Handle(NativeHandle::WIN32HANDLETYPE_KMT, handle);
break;
vk::Move<vk::VkFence> createExportableFence (const vk::DeviceInterface& vkd,
vk::VkDevice device,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalFenceHandleTypeFlagBits externalType)
{
- const vk::VkExportFenceCreateInfoKHR exportCreateInfo =
+ const vk::VkExportFenceCreateInfo exportCreateInfo =
{
- vk::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_FENCE_CREATE_INFO,
DE_NULL,
- (vk::VkExternalFenceHandleTypeFlagsKHR)externalType
+ (vk::VkExternalFenceHandleTypeFlags)externalType
};
const vk::VkFenceCreateInfo createInfo =
{
int getFenceFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType)
+ vk::VkExternalFenceHandleTypeFlagBits externalType)
{
const vk::VkFenceGetFdInfoKHR info =
{
void getFenceNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& nativeHandle)
{
- if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
const vk::VkFenceGetFdInfoKHR info =
{
TCU_CHECK(fd >= 0);
nativeHandle = fd;
}
- else if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ else if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
const vk::VkFenceGetWin32HandleInfoKHR info =
{
switch (externalType)
{
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
nativeHandle.setWin32Handle(NativeHandle::WIN32HANDLETYPE_NT, handle);
break;
- case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
nativeHandle.setWin32Handle(NativeHandle::WIN32HANDLETYPE_KMT, handle);
break;
void importFence (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
const vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkFenceImportFlagsKHR flags)
+ vk::VkFenceImportFlags flags)
{
- if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
const vk::VkImportFenceFdInfoKHR importInfo =
{
VK_CHECK(vkd.importFenceFdKHR(device, &importInfo));
handle.disown();
}
- else if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ else if (externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_FENCE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
const vk::VkImportFenceWin32HandleInfoKHR importInfo =
{
DE_FATAL("Unknown fence external handle type");
}
-vk::Move<vk::VkFence> createAndImportFence (const vk::DeviceInterface& vkd,
- const vk::VkDevice device,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType,
- NativeHandle& handle,
- vk::VkFenceImportFlagsKHR flags)
+vk::Move<vk::VkFence> createAndImportFence (const vk::DeviceInterface& vkd,
+ const vk::VkDevice device,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
+ NativeHandle& handle,
+ vk::VkFenceImportFlags flags)
{
vk::Move<vk::VkFence> fence (createFence(vkd, device));
return fence;
}
-vk::Move<vk::VkSemaphore> createExportableSemaphore (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+vk::Move<vk::VkSemaphore> createExportableSemaphore (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
- const vk::VkExportSemaphoreCreateInfoKHR exportCreateInfo =
+ const vk::VkExportSemaphoreCreateInfo exportCreateInfo =
{
- vk::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_SEMAPHORE_CREATE_INFO,
DE_NULL,
- (vk::VkExternalSemaphoreHandleTypeFlagsKHR)externalType
+ (vk::VkExternalSemaphoreHandleTypeFlags)externalType
};
const vk::VkSemaphoreCreateInfo createInfo =
{
return vk::createSemaphore(vkd, device, &createInfo);
}
-int getSemaphoreFd (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType)
+int getSemaphoreFd (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkSemaphore semaphore,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType)
{
const vk::VkSemaphoreGetFdInfoKHR info =
{
return fd;
}
-void getSemaphoreNative (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType,
- NativeHandle& nativeHandle)
+void getSemaphoreNative (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkSemaphore semaphore,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
+ NativeHandle& nativeHandle)
{
- if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
const vk::VkSemaphoreGetFdInfoKHR info =
{
TCU_CHECK(fd >= 0);
nativeHandle = fd;
}
- else if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ else if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
const vk::VkSemaphoreGetWin32HandleInfoKHR info =
{
switch (externalType)
{
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT:
nativeHandle.setWin32Handle(NativeHandle::WIN32HANDLETYPE_NT, handle);
break;
- case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR:
+ case vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT:
nativeHandle.setWin32Handle(NativeHandle::WIN32HANDLETYPE_KMT, handle);
break;
void importSemaphore (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
const vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkSemaphoreImportFlagsKHR flags)
+ vk::VkSemaphoreImportFlags flags)
{
- if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT)
{
const vk::VkImportSemaphoreFdInfoKHR importInfo =
{
VK_CHECK(vkd.importSemaphoreFdKHR(device, &importInfo));
handle.disown();
}
- else if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ else if (externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
const vk::VkImportSemaphoreWin32HandleInfoKHR importInfo =
{
vk::Move<vk::VkSemaphore> createAndImportSemaphore (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkSemaphoreImportFlagsKHR flags)
+ vk::VkSemaphoreImportFlags flags)
{
vk::Move<vk::VkSemaphore> semaphore (createSemaphore(vkd, device));
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkBuffer buffer,
deUint32& exportedMemoryTypeIndex)
{
exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits);
- const vk::VkMemoryDedicatedAllocateInfoKHR dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
DE_NULL,
(vk::VkImage)0,
buffer
};
- const vk::VkExportMemoryAllocateInfoKHR exportInfo =
+ const vk::VkExportMemoryAllocateInfo exportInfo =
{
- vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
!!buffer ? &dedicatedInfo : DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkMemoryAllocateInfo info =
{
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkImage image,
deUint32& exportedMemoryTypeIndex)
{
exportedMemoryTypeIndex = chooseMemoryType(requirements.memoryTypeBits);
- const vk::VkMemoryDedicatedAllocateInfoKHR dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
DE_NULL,
image,
(vk::VkBuffer)0
};
- const vk::VkExportMemoryAllocateInfoKHR exportInfo =
+ const vk::VkExportMemoryAllocateInfo exportInfo =
{
- vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
!!image ? &dedicatedInfo : DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkMemoryAllocateInfo info =
{
const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
bool hostVisible,
vk::VkBuffer buffer,
deUint32& exportedMemoryTypeIndex)
if (((requirements.memoryTypeBits & (1u << memoryTypeIndex)) != 0)
&& (((properties.memoryTypes[memoryTypeIndex].propertyFlags & vk::VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT) != 0) == hostVisible))
{
- const vk::VkMemoryDedicatedAllocateInfoKHR dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
DE_NULL,
(vk::VkImage)0,
buffer
};
- const vk::VkExportMemoryAllocateInfoKHR exportInfo =
+ const vk::VkExportMemoryAllocateInfo exportInfo =
{
- vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXPORT_MEMORY_ALLOCATE_INFO,
!!buffer ? &dedicatedInfo : DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkMemoryAllocateInfo info =
{
vk::VkBuffer buffer,
vk::VkImage image,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle)
{
DE_ASSERT(!buffer || !image);
- if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT_KHR)
+ if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_FD_BIT)
{
const vk::VkImportMemoryFdInfoKHR importInfo =
{
externalType,
handle.getFd()
};
- const vk::VkMemoryDedicatedAllocateInfoKHR dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
&importInfo,
image,
buffer,
return memory;
}
- else if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT_KHR
- || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT_KHR)
+ else if (externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_BIT
+ || externalType == vk::VK_EXTERNAL_MEMORY_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT)
{
const vk::VkImportMemoryWin32HandleInfoKHR importInfo =
{
handle.getWin32Handle(),
DE_NULL
};
- const vk::VkMemoryDedicatedAllocateInfoKHR dedicatedInfo =
+ const vk::VkMemoryDedicatedAllocateInfo dedicatedInfo =
{
- vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_MEMORY_DEDICATED_ALLOCATE_INFO,
&importInfo,
image,
buffer,
vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle)
{
vk::VkDevice device,
vk::VkBuffer buffer,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle)
{
vk::VkDevice device,
vk::VkImage image,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle)
{
vk::Move<vk::VkBuffer> createExternalBuffer (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkDeviceSize size,
vk::VkBufferCreateFlags createFlags,
vk::VkBufferUsageFlags usageFlags)
{
- const vk::VkExternalMemoryBufferCreateInfoKHR externalCreateInfo =
+ const vk::VkExternalMemoryBufferCreateInfo externalCreateInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_BUFFER_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkBufferCreateInfo createInfo =
{
vk::Move<vk::VkImage> createExternalImage (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkFormat format,
deUint32 width,
deUint32 height,
vk::VkImageCreateFlags createFlags,
vk::VkImageUsageFlags usageFlags)
{
- const vk::VkExternalMemoryImageCreateInfoKHR externalCreateInfo =
+ const vk::VkExternalMemoryImageCreateInfo externalCreateInfo =
{
- vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_EXTERNAL_MEMORY_IMAGE_CREATE_INFO,
DE_NULL,
- (vk::VkExternalMemoryHandleTypeFlagsKHR)externalType
+ (vk::VkExternalMemoryHandleTypeFlags)externalType
};
const vk::VkImageCreateInfo createInfo =
{
NativeHandle& operator= (const NativeHandle&);
};
-const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR type);
-const char* externalFenceTypeToName (vk::VkExternalFenceHandleTypeFlagBitsKHR type);
-const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBitsKHR type);
+const char* externalSemaphoreTypeToName (vk::VkExternalSemaphoreHandleTypeFlagBits type);
+const char* externalFenceTypeToName (vk::VkExternalFenceHandleTypeFlagBits type);
+const char* externalMemoryTypeToName (vk::VkExternalMemoryHandleTypeFlagBits type);
enum Permanence
{
TRANSFERENCE_REFERENCE
};
-bool isSupportedPermanence (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR type,
+bool isSupportedPermanence (vk::VkExternalSemaphoreHandleTypeFlagBits type,
Permanence permanence);
-Transference getHandelTypeTransferences (vk::VkExternalSemaphoreHandleTypeFlagBitsKHR type);
+Transference getHandelTypeTransferences (vk::VkExternalSemaphoreHandleTypeFlagBits type);
-bool isSupportedPermanence (vk::VkExternalFenceHandleTypeFlagBitsKHR type,
+bool isSupportedPermanence (vk::VkExternalFenceHandleTypeFlagBits type,
Permanence permanence);
-Transference getHandelTypeTransferences (vk::VkExternalFenceHandleTypeFlagBitsKHR type);
+Transference getHandelTypeTransferences (vk::VkExternalFenceHandleTypeFlagBits type);
int getMemoryFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType);
+ vk::VkExternalMemoryHandleTypeFlagBits externalType);
void getMemoryNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkDeviceMemory memory,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
NativeHandle& nativeHandle);
vk::Move<vk::VkSemaphore> createExportableSemaphore (const vk::DeviceInterface& vkd,
vk::VkDevice device,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType);
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType);
int getSemaphoreFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType);
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType);
void getSemaphoreNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& nativeHandle);
void importSemaphore (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
const vk::VkSemaphore semaphore,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkSemaphoreImportFlagsKHR flags);
+ vk::VkSemaphoreImportFlags flags);
vk::Move<vk::VkSemaphore> createAndImportSemaphore (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
- vk::VkExternalSemaphoreHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalSemaphoreHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkSemaphoreImportFlagsKHR flags);
+ vk::VkSemaphoreImportFlags flags);
vk::Move<vk::VkFence> createExportableFence (const vk::DeviceInterface& vkd,
vk::VkDevice device,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType);
+ vk::VkExternalFenceHandleTypeFlagBits externalType);
int getFenceFd (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType);
+ vk::VkExternalFenceHandleTypeFlagBits externalType);
void getFenceNative (const vk::DeviceInterface& vkd,
vk::VkDevice device,
vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& nativeHandle);
void importFence (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
const vk::VkFence fence,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkFenceImportFlagsKHR flags);
+ vk::VkFenceImportFlags flags);
vk::Move<vk::VkFence> createAndImportFence (const vk::DeviceInterface& vkd,
const vk::VkDevice device,
- vk::VkExternalFenceHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalFenceHandleTypeFlagBits externalType,
NativeHandle& handle,
- vk::VkFenceImportFlagsKHR flags);
+ vk::VkFenceImportFlags flags);
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32& exportedMemoryTypeIndex);
// If buffer is not null use dedicated allocation
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkBuffer buffer,
deUint32& exportedMemoryTypeIndex);
vk::Move<vk::VkDeviceMemory> allocateExportableMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkImage image,
deUint32& exportedMemoryTypeIndex);
const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
bool hostVisible,
vk::VkBuffer buffer,
deUint32& exportedMemoryTypeIndex);
vk::Move<vk::VkDeviceMemory> importMemory (const vk::DeviceInterface& vkd,
vk::VkDevice device,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle);
vk::VkDevice device,
vk::VkBuffer buffer,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle);
vk::VkDevice device,
vk::VkImage image,
const vk::VkMemoryRequirements& requirements,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
deUint32 memoryTypeIndex,
NativeHandle& handle);
vk::Move<vk::VkBuffer> createExternalBuffer (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkDeviceSize size,
vk::VkBufferCreateFlags createFlags,
vk::VkBufferUsageFlags usageFlags);
vk::Move<vk::VkImage> createExternalImage (const vk::DeviceInterface& vkd,
vk::VkDevice device,
deUint32 queueFamilyIndex,
- vk::VkExternalMemoryHandleTypeFlagBitsKHR externalType,
+ vk::VkExternalMemoryHandleTypeFlagBits externalType,
vk::VkFormat format,
deUint32 width,
deUint32 height,
VkPhysicalDevice physicalDevice,
deUint32 apiVersion,
deUint32 queueIndex,
- const VkPhysicalDeviceFeatures2KHR& enabledFeatures,
+ const VkPhysicalDeviceFeatures2& enabledFeatures,
const vector<string>& enabledExtensions,
const tcu::CommandLine& cmdLine)
{
struct DeviceFeatures
{
- VkPhysicalDeviceFeatures2KHR coreFeatures;
- VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR samplerYCbCrConversionFeatures;
+ VkPhysicalDeviceFeatures2 coreFeatures;
+ VkPhysicalDeviceSamplerYcbcrConversionFeatures samplerYCbCrConversionFeatures;
DeviceFeatures (const InstanceInterface& vki,
VkPhysicalDevice physicalDevice,
curExtPoint = &samplerYCbCrConversionFeatures.pNext;
}
- vki.getPhysicalDeviceFeatures2KHR(physicalDevice, &coreFeatures);
+ vki.getPhysicalDeviceFeatures2(physicalDevice, &coreFeatures);
}
else
coreFeatures.features = getPhysicalDeviceFeatures(vki, physicalDevice);
vk::VkPhysicalDevice Context::getPhysicalDevice (void) const { return m_device->getPhysicalDevice(); }
deUint32 Context::getDeviceVersion (void) const { return m_device->getDeviceVersion(); }
const vk::VkPhysicalDeviceFeatures& Context::getDeviceFeatures (void) const { return m_device->getDeviceFeatures(); }
-const vk::VkPhysicalDeviceFeatures2KHR& Context::getDeviceFeatures2 (void) const { return m_device->getDeviceFeatures2(); }
+const vk::VkPhysicalDeviceFeatures2& Context::getDeviceFeatures2 (void) const { return m_device->getDeviceFeatures2(); }
const vk::VkPhysicalDeviceProperties& Context::getDeviceProperties (void) const { return m_device->getDeviceProperties(); }
const vector<string>& Context::getDeviceExtensions (void) const { return m_device->getDeviceExtensions(); }
vk::VkDevice Context::getDevice (void) const { return m_device->getDevice(); }
vk::VkPhysicalDevice getPhysicalDevice (void) const;
deUint32 getDeviceVersion (void) const;
const vk::VkPhysicalDeviceFeatures& getDeviceFeatures (void) const;
- const vk::VkPhysicalDeviceFeatures2KHR& getDeviceFeatures2 (void) const;
+ const vk::VkPhysicalDeviceFeatures2& getDeviceFeatures2 (void) const;
const vk::VkPhysicalDeviceProperties& getDeviceProperties (void) const;
const std::vector<std::string>& getDeviceExtensions (void) const;
vk::VkDevice getDevice (void) const;
deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
- const vector<VkPhysicalDeviceGroupPropertiesKHR> deviceGroupProps = enumeratePhysicalDeviceGroupsKHR(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
1u, //queueCount;
&queuePriority, //pQueuePriorities;
};
- const VkDeviceGroupDeviceCreateInfoKHR deviceGroupInfo =
+ const VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
DE_NULL, //pNext
deviceExtensions.push_back("VK_KHR_device_group");
deviceExtensions.push_back("VK_KHR_swapchain");
- const vector<VkPhysicalDeviceGroupPropertiesKHR> deviceGroupProps = enumeratePhysicalDeviceGroupsKHR(instHelper.vki, *instHelper.instance);
+ const vector<VkPhysicalDeviceGroupProperties> deviceGroupProps = enumeratePhysicalDeviceGroups(instHelper.vki, *instHelper.instance);
const std::vector<VkQueueFamilyProperties> queueProps = getPhysicalDeviceQueueFamilyProperties(instHelper.vki, deviceGroupProps[devGroupIdx].physicalDevices[deviceIdx]);
for (size_t queueNdx = 0; queueNdx < queueProps.size(); queueNdx++)
{
1u, //queueCount;
&queuePriority, //pQueuePriorities;
};
- const VkDeviceGroupDeviceCreateInfoKHR deviceGroupInfo =
+ const VkDeviceGroupDeviceCreateInfo deviceGroupInfo =
{
VK_STRUCTURE_TYPE_DEVICE_GROUP_DEVICE_CREATE_INFO_KHR, //stype
DE_NULL, //pNext
{
switch (format)
{
- case vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
- case vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G8B8G8R8_422_UNORM:
+ case vk::VK_FORMAT_B8G8R8G8_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
return UVec4(8, 8, 8, 0);
- case vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR:
+ case vk::VK_FORMAT_R10X6_UNORM_PACK16:
return UVec4(10, 0, 0, 0);
- case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
+ case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
return UVec4(10, 10, 0, 0);
- case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
+ case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
return UVec4(10, 10, 10, 10);
- case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
+ case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
return UVec4(10, 10, 10, 0);
- case vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR:
+ case vk::VK_FORMAT_R12X4_UNORM_PACK16:
return UVec4(12, 0, 0, 0);
- case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
+ case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
return UVec4(12, 12, 0, 0);
- case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
+ case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
return UVec4(12, 12, 12, 12);
- case vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
- case vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G16B16G16R16_422_UNORM:
+ case vk::VK_FORMAT_B16G16R16G16_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
return UVec4(16, 16, 16, 0);
default:
case vk::VK_FORMAT_R8G8B8A8_UNORM:
case vk::VK_FORMAT_B8G8R8A8_UNORM:
case vk::VK_FORMAT_A8B8G8R8_UNORM_PACK32:
- case vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
- case vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G8B8G8R8_422_UNORM:
+ case vk::VK_FORMAT_B8G8R8G8_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
return low;
case vk::VK_FORMAT_A2R10G10B10_UNORM_PACK32:
case vk::VK_FORMAT_A2B10G10R10_UNORM_PACK32:
case vk::VK_FORMAT_R16G16B16_UNORM:
case vk::VK_FORMAT_R16G16B16A16_UNORM:
- case vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR:
- case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
- case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
- case vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_R10X6_UNORM_PACK16:
+ case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
+ case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
+ case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+ case vk::VK_FORMAT_R12X4_UNORM_PACK16:
+ case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
+ case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+ case vk::VK_FORMAT_G16B16G16R16_422_UNORM:
+ case vk::VK_FORMAT_B16G16R16G16_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
return fp16;
default:
case vk::VK_FORMAT_R8G8B8A8_UNORM:
case vk::VK_FORMAT_B8G8R8A8_UNORM:
case vk::VK_FORMAT_A8B8G8R8_UNORM_PACK32:
- case vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
- case vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G8B8G8R8_422_UNORM:
+ case vk::VK_FORMAT_B8G8R8G8_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
return reallyLow;
case vk::VK_FORMAT_A2R10G10B10_UNORM_PACK32:
case vk::VK_FORMAT_A2B10G10R10_UNORM_PACK32:
case vk::VK_FORMAT_R16G16B16_UNORM:
case vk::VK_FORMAT_R16G16B16A16_UNORM:
- case vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR:
- case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
- case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
- case vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_R10X6_UNORM_PACK16:
+ case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
+ case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
+ case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+ case vk::VK_FORMAT_R12X4_UNORM_PACK16:
+ case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
+ case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+ case vk::VK_FORMAT_G16B16G16R16_422_UNORM:
+ case vk::VK_FORMAT_B16G16R16G16_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
return fp16;
default:
}
}
-Interval rangeExpandChroma (vk::VkSamplerYcbcrRangeKHR range,
+Interval rangeExpandChroma (vk::VkSamplerYcbcrRange range,
const FloatFormat& conversionFormat,
const deUint32 bits,
const Interval& sample)
switch (range)
{
- case vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR:
+ case vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
return conversionFormat.roundOut(sample - conversionFormat.roundOut(Interval((double)(0x1u << (bits - 1u)) / (double)((0x1u << bits) - 1u)), false), false);
- case vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR:
+ case vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
{
const Interval a (conversionFormat.roundOut(sample * Interval((double)(values - 1u)), false));
const Interval dividend (conversionFormat.roundOut(a - Interval((double)(128u * (0x1u << (bits - 8u)))), false));
}
}
-Interval rangeExpandLuma (vk::VkSamplerYcbcrRangeKHR range,
+Interval rangeExpandLuma (vk::VkSamplerYcbcrRange range,
const FloatFormat& conversionFormat,
const deUint32 bits,
const Interval& sample)
switch (range)
{
- case vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR:
+ case vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
return conversionFormat.roundOut(sample, false);
- case vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR:
+ case vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
{
const Interval a (conversionFormat.roundOut(sample * Interval((double)(values - 1u)), false));
const Interval dividend (conversionFormat.roundOut(a - Interval((double)(16u * (0x1u << (bits - 8u)))), false));
return result;
}
-void convertColor (vk::VkSamplerYcbcrModelConversionKHR colorModel,
- vk::VkSamplerYcbcrRangeKHR range,
+void convertColor (vk::VkSamplerYcbcrModelConversion colorModel,
+ vk::VkSamplerYcbcrRange range,
const FloatFormat& conversionFormat,
const UVec4& bitDepth,
const Interval input[4],
{
switch (colorModel)
{
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
{
for (size_t ndx = 0; ndx < 4; ndx++)
output[ndx] = input[ndx];
break;
}
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
{
output[0] = clampMaybe(rangeExpandChroma(range, conversionFormat, bitDepth[0], input[0]), -0.5, 0.5);
output[1] = clampMaybe(rangeExpandLuma(range, conversionFormat, bitDepth[1], input[1]), 0.0, 1.0);
break;
}
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
{
const Interval y (rangeExpandLuma(range, conversionFormat, bitDepth[1], input[1]));
const Interval cr (rangeExpandChroma(range, conversionFormat, bitDepth[0], input[0]));
break;
}
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
{
const Interval y (rangeExpandLuma(range, conversionFormat, bitDepth[1], input[1]));
const Interval cr (rangeExpandChroma(range, conversionFormat, bitDepth[0], input[0]));
break;
}
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
{
const Interval y (rangeExpandLuma(range, conversionFormat, bitDepth[1], input[1]));
const Interval cr (rangeExpandChroma(range, conversionFormat, bitDepth[0], input[0]));
DE_FATAL("Unknown YCbCrModel");
}
- if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR)
+ if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY)
{
for (int ndx = 0; ndx < 3; ndx++)
output[ndx] = clampMaybe(output[ndx], 0.0, 1.0);
}
Interval calculateImplicitChromaUV (const FloatFormat& coordFormat,
- vk::VkChromaLocationKHR offset,
+ vk::VkChromaLocation offset,
const Interval& uv)
{
- if (offset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR)
+ if (offset == vk::VK_CHROMA_LOCATION_COSITED_EVEN)
return coordFormat.roundOut(0.5 * coordFormat.roundOut(uv + 0.5, false), false);
else
return coordFormat.roundOut(0.5 * uv, false);
Interval reconstructLinearXChromaSample (const FloatFormat& filteringFormat,
const FloatFormat& conversionFormat,
- vk::VkChromaLocationKHR offset,
+ vk::VkChromaLocation offset,
vk::VkSamplerAddressMode addressModeU,
vk::VkSamplerAddressMode addressModeV,
const ChannelAccess& access,
{
const int subI = divFloor(i, 2);
- if (offset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR)
+ if (offset == vk::VK_CHROMA_LOCATION_COSITED_EVEN)
{
if (i % 2 == 0)
return lookupWrapped(access, conversionFormat, addressModeU, addressModeV, IVec2(subI, j));
return filteringFormat.roundOut(a + b, false);
}
}
- else if (offset == vk::VK_CHROMA_LOCATION_MIDPOINT_KHR)
+ else if (offset == vk::VK_CHROMA_LOCATION_MIDPOINT)
{
if (i % 2 == 0)
{
Interval reconstructLinearXYChromaSample (const FloatFormat& filteringFormat,
const FloatFormat& conversionFormat,
- vk::VkChromaLocationKHR xOffset,
- vk::VkChromaLocationKHR yOffset,
+ vk::VkChromaLocation xOffset,
+ vk::VkChromaLocation yOffset,
vk::VkSamplerAddressMode addressModeU,
vk::VkSamplerAddressMode addressModeV,
const ChannelAccess& access,
int i,
int j)
{
- const int subI = xOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR
+ const int subI = xOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN
? divFloor(i, 2)
: (i % 2 == 0 ? divFloor(i, 2) - 1 : divFloor(i, 2));
- const int subJ = yOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR
+ const int subJ = yOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN
? divFloor(j, 2)
: (j % 2 == 0 ? divFloor(j, 2) - 1 : divFloor(j, 2));
- const double a = xOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR
+ const double a = xOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN
? (i % 2 == 0 ? 0.0 : 0.5)
: (i % 2 == 0 ? 0.25 : 0.75);
- const double b = yOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR
+ const double b = yOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN
? (j % 2 == 0 ? 0.0 : 0.5)
: (j % 2 == 0 ? 0.25 : 0.75);
const FloatFormat& conversionFormat,
const deUint32 subTexelPrecisionBits,
vk::VkFilter filter,
- vk::VkSamplerYcbcrModelConversionKHR colorModel,
- vk::VkSamplerYcbcrRangeKHR range,
+ vk::VkSamplerYcbcrModelConversion colorModel,
+ vk::VkSamplerYcbcrRange range,
vk::VkFilter chromaFilter,
- vk::VkChromaLocationKHR xChromaOffset,
- vk::VkChromaLocationKHR yChromaOffset,
+ vk::VkChromaLocation xChromaOffset,
+ vk::VkChromaLocation yChromaOffset,
const vk::VkComponentMapping& componentMapping,
bool explicitReconstruction,
vk::VkSamplerAddressMode addressModeU,
vk::VkSamplerAddressMode addressModeV_,
vk::VkFilter chromaFilter_,
- vk::VkChromaLocationKHR xChromaOffset_,
- vk::VkChromaLocationKHR yChromaOffset_,
+ vk::VkChromaLocation xChromaOffset_,
+ vk::VkChromaLocation yChromaOffset_,
bool explicitReconstruction_,
bool disjoint_,
- vk::VkSamplerYcbcrRangeKHR colorRange_,
- vk::VkSamplerYcbcrModelConversionKHR colorModel_,
+ vk::VkSamplerYcbcrRange colorRange_,
+ vk::VkSamplerYcbcrModelConversion colorModel_,
vk::VkComponentMapping componentMapping_)
: shaderType (shaderType_)
, format (format_)
vk::VkSamplerAddressMode addressModeV;
vk::VkFilter chromaFilter;
- vk::VkChromaLocationKHR xChromaOffset;
- vk::VkChromaLocationKHR yChromaOffset;
+ vk::VkChromaLocation xChromaOffset;
+ vk::VkChromaLocation yChromaOffset;
bool explicitReconstruction;
bool disjoint;
- vk::VkSamplerYcbcrRangeKHR colorRange;
- vk::VkSamplerYcbcrModelConversionKHR colorModel;
+ vk::VkSamplerYcbcrRange colorRange;
+ vk::VkSamplerYcbcrModelConversion colorModel;
vk::VkComponentMapping componentMapping;
};
vk::VkFilter textureFilter,
vk::VkSamplerAddressMode addressModeU,
vk::VkSamplerAddressMode addressModeV,
- vk::VkSamplerYcbcrConversionKHR conversion)
+ vk::VkSamplerYcbcrConversion conversion)
{
#if !defined(FAKE_COLOR_CONVERSION)
- const vk::VkSamplerYcbcrConversionInfoKHR samplerConversionInfo =
+ const vk::VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
- vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
conversion
};
{
vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
DE_NULL,
- disjoint ? (vk::VkImageCreateFlags)vk::VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (vk::VkImageCreateFlags)0u,
+ disjoint ? (vk::VkImageCreateFlags)vk::VK_IMAGE_CREATE_DISJOINT_BIT : (vk::VkImageCreateFlags)0u,
vk::VK_IMAGE_TYPE_2D,
format,
vk::VkDevice device,
vk::VkImage image,
vk::VkFormat format,
- vk::VkSamplerYcbcrConversionKHR conversion)
+ vk::VkSamplerYcbcrConversion conversion)
{
#if !defined(FAKE_COLOR_CONVERSION)
- const vk::VkSamplerYcbcrConversionInfoKHR conversionInfo =
+ const vk::VkSamplerYcbcrConversionInfo conversionInfo =
{
- vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
conversion
};
return vk::createImageView(vkd, device, &viewInfo);
}
-vk::Move<vk::VkSamplerYcbcrConversionKHR> createConversion (const vk::DeviceInterface& vkd,
- vk::VkDevice device,
- vk::VkFormat format,
- vk::VkSamplerYcbcrModelConversionKHR colorModel,
- vk::VkSamplerYcbcrRangeKHR colorRange,
- vk::VkChromaLocationKHR xChromaOffset,
- vk::VkChromaLocationKHR yChromaOffset,
- vk::VkFilter chromaFilter,
- const vk::VkComponentMapping& componentMapping,
- bool explicitReconstruction)
+vk::Move<vk::VkSamplerYcbcrConversion> createConversion (const vk::DeviceInterface& vkd,
+ vk::VkDevice device,
+ vk::VkFormat format,
+ vk::VkSamplerYcbcrModelConversion colorModel,
+ vk::VkSamplerYcbcrRange colorRange,
+ vk::VkChromaLocation xChromaOffset,
+ vk::VkChromaLocation yChromaOffset,
+ vk::VkFilter chromaFilter,
+ const vk::VkComponentMapping& componentMapping,
+ bool explicitReconstruction)
{
- const vk::VkSamplerYcbcrConversionCreateInfoKHR conversionInfo =
+ const vk::VkSamplerYcbcrConversionCreateInfo conversionInfo =
{
- vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+ vk::VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
DE_NULL,
format,
explicitReconstruction ? VK_TRUE : VK_FALSE
};
- return vk::createSamplerYcbcrConversionKHR(vkd, device, &conversionInfo);
+ return vk::createSamplerYcbcrConversion(vkd, device, &conversionInfo);
}
void evalShader (Context& context,
vk::VkFilter textureFilter,
vk::VkSamplerAddressMode addressModeU,
vk::VkSamplerAddressMode addressModeV,
- vk::VkSamplerYcbcrModelConversionKHR colorModel,
- vk::VkSamplerYcbcrRangeKHR colorRange,
- vk::VkChromaLocationKHR xChromaOffset,
- vk::VkChromaLocationKHR yChromaOffset,
+ vk::VkSamplerYcbcrModelConversion colorModel,
+ vk::VkSamplerYcbcrRange colorRange,
+ vk::VkChromaLocation xChromaOffset,
+ vk::VkChromaLocation yChromaOffset,
vk::VkFilter chromaFilter,
const vk::VkComponentMapping& componentMapping,
bool explicitReconstruction,
const vk::DeviceInterface& vkd (context.getDeviceInterface());
const vk::VkDevice device (context.getDevice());
#if !defined(FAKE_COLOR_CONVERSION)
- const vk::Unique<vk::VkSamplerYcbcrConversionKHR> conversion (createConversion(vkd, device, format, colorModel, colorRange, xChromaOffset, yChromaOffset, chromaFilter, componentMapping, explicitReconstruction));
+ const vk::Unique<vk::VkSamplerYcbcrConversion> conversion (createConversion(vkd, device, format, colorModel, colorRange, xChromaOffset, yChromaOffset, chromaFilter, componentMapping, explicitReconstruction));
const vk::Unique<vk::VkSampler> sampler (createSampler(vkd, device, textureFilter, addressModeU, addressModeV, *conversion));
#else
DE_UNREF(colorModel);
DE_UNREF(explicitReconstruction);
DE_UNREF(componentMapping);
DE_UNREF(createConversion);
- const vk::Unique<vk::VkSampler> sampler (createSampler(vkd, device, textureFilter, addressModeU, addressModeV, (vk::VkSamplerYcbcrConversionKHR)0u));
+ const vk::Unique<vk::VkSampler> sampler (createSampler(vkd, device, textureFilter, addressModeU, addressModeV, (vk::VkSamplerYcbcrConversion)0u));
#endif
const vk::Unique<vk::VkImage> image (createImage(vkd, device, format, size, disjoint, imageTiling));
const vk::MemoryRequirement memoryRequirement (imageTiling == vk::VK_IMAGE_TILING_OPTIMAL
? vk::MemoryRequirement::Any
: vk::MemoryRequirement::HostVisible);
- const vk::VkImageCreateFlags createFlags (disjoint ? vk::VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (vk::VkImageCreateFlagBits)0u);
+ const vk::VkImageCreateFlags createFlags (disjoint ? vk::VK_IMAGE_CREATE_DISJOINT_BIT : (vk::VkImageCreateFlagBits)0u);
const vector<AllocationSp> imageMemory (allocateAndBindImageMemory(vkd, device, context.getDefaultAllocator(), *image, format, createFlags, memoryRequirement));
#if defined(FAKE_COLOR_CONVERSION)
- const vk::Unique<vk::VkImageView> imageView (createImageView(vkd, device, *image, format, (vk::VkSamplerYcbcrConversionKHR)0));
+ const vk::Unique<vk::VkImageView> imageView (createImageView(vkd, device, *image, format, (vk::VkSamplerYcbcrConversion)0));
#else
const vk::Unique<vk::VkImageView> imageView (createImageView(vkd, device, *image, format, *conversion));
#endif
{
switch (format)
{
- case vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
- case vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
- case vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
+ case vk::VK_FORMAT_G8B8G8R8_422_UNORM:
+ case vk::VK_FORMAT_B8G8R8G8_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G16B16G16R16_422_UNORM:
+ case vk::VK_FORMAT_B16G16R16G16_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
return true;
default:
{
switch (format)
{
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
return true;
default:
? properties.optimalTilingFeatures
: properties.linearTilingFeatures);
- if ((features & (vk::VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR | vk::VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR)) == 0)
+ if ((features & (vk::VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT | vk::VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT)) == 0)
TCU_THROW(NotSupportedError, "Format doesn't support YCbCr conversions");
if ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_BIT) == 0)
TCU_THROW(NotSupportedError, "Format doesn't support sampling");
- if (config.textureFilter == vk::VK_FILTER_LINEAR && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR) == 0))
+ if (config.textureFilter == vk::VK_FILTER_LINEAR && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support YCbCr linear chroma reconstruction");
- if (config.chromaFilter == vk::VK_FILTER_LINEAR && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT_KHR) == 0))
+ if (config.chromaFilter == vk::VK_FILTER_LINEAR && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_LINEAR_FILTER_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support YCbCr linear chroma reconstruction");
- if (config.chromaFilter != config.textureFilter && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT_KHR) == 0))
+ if (config.chromaFilter != config.textureFilter && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_SEPARATE_RECONSTRUCTION_FILTER_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support different chroma and texture filters");
- if (config.explicitReconstruction && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT_KHR) == 0))
+ if (config.explicitReconstruction && ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_FORCEABLE_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support explicit chroma reconstruction");
- if (config.disjoint && ((features & vk::VK_FORMAT_FEATURE_DISJOINT_BIT_KHR) == 0))
+ if (config.disjoint && ((features & vk::VK_FORMAT_FEATURE_DISJOINT_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't disjoint planes");
- if (isXChromaSubsampled(config.format) && (config.xChromaOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR) && ((features & vk::VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR) == 0))
+ if (isXChromaSubsampled(config.format) && (config.xChromaOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN) && ((features & vk::VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support cosited chroma samples");
- if (isXChromaSubsampled(config.format) && (config.xChromaOffset == vk::VK_CHROMA_LOCATION_MIDPOINT_KHR) && ((features & vk::VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR) == 0))
+ if (isXChromaSubsampled(config.format) && (config.xChromaOffset == vk::VK_CHROMA_LOCATION_MIDPOINT) && ((features & vk::VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support midpoint chroma samples");
- if (isYChromaSubsampled(config.format) && (config.yChromaOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR) && ((features & vk::VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR) == 0))
+ if (isYChromaSubsampled(config.format) && (config.yChromaOffset == vk::VK_CHROMA_LOCATION_COSITED_EVEN) && ((features & vk::VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support cosited chroma samples");
- if (isYChromaSubsampled(config.format) && (config.yChromaOffset == vk::VK_CHROMA_LOCATION_MIDPOINT_KHR) && ((features & vk::VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR) == 0))
+ if (isYChromaSubsampled(config.format) && (config.yChromaOffset == vk::VK_CHROMA_LOCATION_MIDPOINT) && ((features & vk::VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't support midpoint chroma samples");
- if ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT_KHR) != 0)
+ if ((features & vk::VK_FORMAT_FEATURE_SAMPLED_IMAGE_YCBCR_CONVERSION_CHROMA_RECONSTRUCTION_EXPLICIT_BIT) != 0)
explicitReconstruction = true;
log << TestLog::Message << "FormatFeatures: " << vk::getFormatFeatureFlagsStr(features) << TestLog::EndMessage;
switch (config.colorRange)
{
- case vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR:
+ case vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL:
source << "highp float cr = r - (float(" << (0x1u << (bits[0] - 0x1u)) << ") / float(" << ((0x1u << bits[0]) - 1u) << "));\n";
source << "highp float y = g;\n";
source << "highp float cb = b - (float(" << (0x1u << (bits[2] - 0x1u)) << ") / float(" << ((0x1u << bits[2]) - 1u) << "));\n";
break;
- case vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR:
+ case vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW:
source << "highp float cr = (r * float(" << ((0x1u << bits[0]) - 1u) << ") - float(" << (128u * (0x1u << (bits[0] - 8))) << ")) / float(" << (224u * (0x1u << (bits[0] - 8))) << ");\n";
source << "highp float y = (g * float(" << ((0x1u << bits[1]) - 1u) << ") - float(" << (16u * (0x1u << (bits[1] - 8))) << ")) / float(" << (219u * (0x1u << (bits[1] - 8))) << ");\n";
source << "highp float cb = (b * float(" << ((0x1u << bits[2]) - 1u) << ") - float(" << (128u * (0x1u << (bits[2] - 8))) << ")) / float(" << (224u * (0x1u << (bits[2] - 8))) << ");\n";
switch (config.colorModel)
{
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY:
source << "color = vec4(r, g, b, a);\n";
break;
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY:
source << "color = vec4(cr, y, cb, a);\n";
break;
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601:
source << "color = vec4(y + 1.402 * cr, y - float(" << (0.202008 / 0.587) << ") * cb - float(" << (0.419198 / 0.587) << ") * cr, y + 1.772 * cb, a);\n";
break;
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709:
source << "color = vec4(y + 1.5748 * cr, y - float(" << (0.13397432 / 0.7152) << ") * cb - float(" << (0.33480248 / 0.7152) << ") * cr, y + 1.8556 * cb, a);\n";
break;
- case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR:
+ case vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020:
source << "color = vec4(y + 1.4746 * cr, (y - float(" << (0.11156702 / 0.6780) << ") * cb) - float(" << (0.38737742 / 0.6780) << ") * cr, y + 1.8814 * cb, a);\n";
break;
case vk::VK_FORMAT_B4G4R4A4_UNORM_PACK16:
case vk::VK_FORMAT_B5G5R5A1_UNORM_PACK16:
case vk::VK_FORMAT_B8G8R8A8_UNORM:
- case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
+ case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
+ case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
case vk::VK_FORMAT_R16G16B16A16_UNORM:
case vk::VK_FORMAT_R4G4B4A4_UNORM_PACK16:
case vk::VK_FORMAT_R5G5B5A1_UNORM_PACK16:
case vk::VK_FORMAT_R8G8B8A8_UNORM:
return 4;
- case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
+ case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B16G16R16G16_422_UNORM:
case vk::VK_FORMAT_B5G6R5_UNORM_PACK16:
- case vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
+ case vk::VK_FORMAT_B8G8R8G8_422_UNORM:
case vk::VK_FORMAT_B8G8R8_UNORM:
- case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
- case vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+ case vk::VK_FORMAT_G16B16G16R16_422_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
+ case vk::VK_FORMAT_G8B8G8R8_422_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
case vk::VK_FORMAT_R16G16B16_UNORM:
case vk::VK_FORMAT_R5G6B5_UNORM_PACK16:
case vk::VK_FORMAT_R8G8B8_UNORM:
return 3;
- case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
+ case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
+ case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
return 2;
- case vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR:
- case vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR:
+ case vk::VK_FORMAT_R10X6_UNORM_PACK16:
+ case vk::VK_FORMAT_R12X4_UNORM_PACK16:
return 1;
default:
struct RangeNamePair
{
const char* name;
- vk::VkSamplerYcbcrRangeKHR value;
+ vk::VkSamplerYcbcrRange value;
};
struct ChromaLocationNamePair
{
const char* name;
- vk::VkChromaLocationKHR value;
+ vk::VkChromaLocation value;
};
void initTests (tcu::TestCaseGroup* testGroup)
vk::VK_FORMAT_A2B10G10R10_UNORM_PACK32,
vk::VK_FORMAT_R16G16B16_UNORM,
vk::VK_FORMAT_R16G16B16A16_UNORM,
- vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR,
- vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
- vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR,
- vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
- vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
- vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR
+ vk::VK_FORMAT_R10X6_UNORM_PACK16,
+ vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+ vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
+ vk::VK_FORMAT_R12X4_UNORM_PACK16,
+ vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
+ vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
+ vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
+ vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
+ vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM
};
const vk::VkFormat xChromaSubsampledFormats[] =
{
- vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
- vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
- vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
- vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
-
- vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
- vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
- vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
- vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
+ vk::VK_FORMAT_G8B8G8R8_422_UNORM,
+ vk::VK_FORMAT_B8G8R8G8_422_UNORM,
+ vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
+ vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
+
+ vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
+ vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
+ vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
+ vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
+ vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G16B16G16R16_422_UNORM,
+ vk::VK_FORMAT_B16G16R16G16_422_UNORM,
+ vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
+ vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
};
const vk::VkFormat xyChromaSubsampledFormats[] =
{
- vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
- vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
- vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
- vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
+ vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
+ vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+ vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
+ vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
};
const struct
{
const char* const name;
- const vk::VkSamplerYcbcrModelConversionKHR value;
+ const vk::VkSamplerYcbcrModelConversion value;
} colorModels[] =
{
- { "rgb_identity", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR },
- { "ycbcr_identity", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY_KHR },
- { "ycbcr_709", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709_KHR },
- { "ycbcr_601", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601_KHR },
- { "ycbcr_2020", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020_KHR }
+ { "rgb_identity", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY },
+ { "ycbcr_identity", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_IDENTITY },
+ { "ycbcr_709", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_709 },
+ { "ycbcr_601", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_601 },
+ { "ycbcr_2020", vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_YCBCR_2020 }
};
const RangeNamePair colorRanges[] =
{
- { "itu_full", vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR },
- { "itu_narrow", vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR }
+ { "itu_full", vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL },
+ { "itu_narrow", vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW }
};
const ChromaLocationNamePair chromaLocations[] =
{
- { "cosited", vk::VK_CHROMA_LOCATION_COSITED_EVEN_KHR },
- { "midpoint", vk::VK_CHROMA_LOCATION_MIDPOINT_KHR }
+ { "cosited", vk::VK_CHROMA_LOCATION_COSITED_EVEN },
+ { "midpoint", vk::VK_CHROMA_LOCATION_MIDPOINT }
};
const struct
{
{ "nearest", vk::VK_FILTER_NEAREST }
};
// Used by the chroma reconstruction tests
- const vk::VkSamplerYcbcrModelConversionKHR defaultColorModel (vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR);
- const vk::VkSamplerYcbcrRangeKHR defaultColorRange (vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR);
+ const vk::VkSamplerYcbcrModelConversion defaultColorModel (vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY);
+ const vk::VkSamplerYcbcrRange defaultColorRange (vk::VK_SAMPLER_YCBCR_RANGE_ITU_FULL);
const vk::VkComponentMapping identitySwizzle =
{
vk::VK_COMPONENT_SWIZZLE_IDENTITY,
for (size_t modelNdx = 0; modelNdx < DE_LENGTH_OF_ARRAY(colorModels); modelNdx++)
{
const char* const colorModelName (colorModels[modelNdx].name);
- const vk::VkSamplerYcbcrModelConversionKHR colorModel (colorModels[modelNdx].value);
+ const vk::VkSamplerYcbcrModelConversion colorModel (colorModels[modelNdx].value);
- if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR && getFormatChannelCount(format) < 3)
+ if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY && getFormatChannelCount(format) < 3)
continue;
de::MovePtr<tcu::TestCaseGroup> colorModelGroup (new tcu::TestCaseGroup(testCtx, colorModelName, ("Tests for color model " + string(colorModelName)).c_str()));
- if (colorModel == vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR)
+ if (colorModel == vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY)
{
for (size_t textureFilterNdx = 0; textureFilterNdx < DE_LENGTH_OF_ARRAY(textureFilters); textureFilterNdx++)
{
const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
const char* const tilingName (imageTilings[tilingNdx].name);
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkSamplerYcbcrRangeKHR colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
- const vk::VkChromaLocationKHR chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkSamplerYcbcrRange colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
+ const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
textureFilter, chromaLocation, chromaLocation, false, false,
for (size_t rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(colorRanges); rangeNdx++)
{
const char* const colorRangeName (colorRanges[rangeNdx].name);
- const vk::VkSamplerYcbcrRangeKHR colorRange (colorRanges[rangeNdx].value);
+ const vk::VkSamplerYcbcrRange colorRange (colorRanges[rangeNdx].value);
// Narrow range doesn't really work with formats that have less than 8 bits
- if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR)
+ if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW)
{
const UVec4 bitDepth (getBitDepth(format));
const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
const char* const tilingName (imageTilings[tilingNdx].name);
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
textureFilter, chromaLocation, chromaLocation, false, false,
colorRange, colorModel, identitySwizzle);
for (size_t xChromaOffsetNdx = 0; xChromaOffsetNdx < DE_LENGTH_OF_ARRAY(chromaLocations); xChromaOffsetNdx++)
{
const char* const xChromaOffsetName (chromaLocations[xChromaOffsetNdx].name);
- const vk::VkChromaLocationKHR xChromaOffset (chromaLocations[xChromaOffsetNdx].value);
+ const vk::VkChromaLocation xChromaOffset (chromaLocations[xChromaOffsetNdx].value);
for (size_t modelNdx = 0; modelNdx < DE_LENGTH_OF_ARRAY(colorModels); modelNdx++)
{
const char* const colorModelName (colorModels[modelNdx].name);
- const vk::VkSamplerYcbcrModelConversionKHR colorModel (colorModels[modelNdx].value);
+ const vk::VkSamplerYcbcrModelConversion colorModel (colorModels[modelNdx].value);
- if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR && getFormatChannelCount(format) < 3)
+ if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY && getFormatChannelCount(format) < 3)
continue;
- if (colorModel == vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR)
+ if (colorModel == vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY)
{
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
const char* const tilingName (imageTilings[tilingNdx].name);
- const vk::VkSamplerYcbcrRangeKHR colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
+ const vk::VkSamplerYcbcrRange colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, vk::VK_FILTER_NEAREST, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, false, false,
colorRange, colorModel, identitySwizzle);
for (size_t rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(colorRanges); rangeNdx++)
{
const char* const colorRangeName (colorRanges[rangeNdx].name);
- const vk::VkSamplerYcbcrRangeKHR colorRange (colorRanges[rangeNdx].value);
+ const vk::VkSamplerYcbcrRange colorRange (colorRanges[rangeNdx].value);
// Narrow range doesn't really work with formats that have less than 8 bits
- if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR)
+ if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW)
{
const UVec4 bitDepth (getBitDepth(format));
const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
const char* const tilingName (imageTilings[tilingNdx].name);
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, vk::VK_FILTER_NEAREST, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, false, false,
colorRange, colorModel, identitySwizzle);
for (size_t xChromaOffsetNdx = 0; xChromaOffsetNdx < DE_LENGTH_OF_ARRAY(chromaLocations); xChromaOffsetNdx++)
{
- const vk::VkChromaLocationKHR xChromaOffset (chromaLocations[xChromaOffsetNdx].value);
+ const vk::VkChromaLocation xChromaOffset (chromaLocations[xChromaOffsetNdx].value);
const char* const xChromaOffsetName (chromaLocations[xChromaOffsetNdx].name);
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_LINEAR, xChromaOffset, yChromaOffset, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, identitySwizzle);
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_LINEAR, xChromaOffset, yChromaOffset, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, swappedChromaSwizzle);
{
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, identitySwizzle);
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation yChromaOffset (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, xChromaOffset, yChromaOffset, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, swappedChromaSwizzle);
const char* const tilingName (imageTilings[tilingNdx].name);
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, chromaLocation, chromaLocation, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, identitySwizzle);
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, chromaLocation, chromaLocation, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, swappedChromaSwizzle);
for (size_t chromaOffsetNdx = 0; chromaOffsetNdx < DE_LENGTH_OF_ARRAY(chromaLocations); chromaOffsetNdx++)
{
const char* const chromaOffsetName (chromaLocations[chromaOffsetNdx].name);
- const vk::VkChromaLocationKHR chromaOffset (chromaLocations[chromaOffsetNdx].value);
+ const vk::VkChromaLocation chromaOffset (chromaLocations[chromaOffsetNdx].value);
for (size_t modelNdx = 0; modelNdx < DE_LENGTH_OF_ARRAY(colorModels); modelNdx++)
{
const char* const colorModelName (colorModels[modelNdx].name);
- const vk::VkSamplerYcbcrModelConversionKHR colorModel (colorModels[modelNdx].value);
+ const vk::VkSamplerYcbcrModelConversion colorModel (colorModels[modelNdx].value);
- if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR && getFormatChannelCount(format) < 3)
+ if (colorModel != vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY && getFormatChannelCount(format) < 3)
continue;
- if (colorModel == vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR)
+ if (colorModel == vk::VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY)
{
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
{
const vk::VkImageTiling tiling (imageTilings[tilingNdx].value);
const char* const tilingName (imageTilings[tilingNdx].name);
- const vk::VkSamplerYcbcrRangeKHR colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
+ const vk::VkSamplerYcbcrRange colorRange (rng.choose<RangeNamePair, const RangeNamePair*>(DE_ARRAY_BEGIN(colorRanges), DE_ARRAY_END(colorRanges)).value);
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
const TestConfig config (shaderType, format, tiling, vk::VK_FILTER_NEAREST, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, chromaOffset, chromaOffset, false, false,
for (size_t rangeNdx = 0; rangeNdx < DE_LENGTH_OF_ARRAY(colorRanges); rangeNdx++)
{
const char* const colorRangeName (colorRanges[rangeNdx].name);
- const vk::VkSamplerYcbcrRangeKHR colorRange (colorRanges[rangeNdx].value);
+ const vk::VkSamplerYcbcrRange colorRange (colorRanges[rangeNdx].value);
// Narrow range doesn't really work with formats that have less than 8 bits
- if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW_KHR)
+ if (colorRange == vk::VK_SAMPLER_YCBCR_RANGE_ITU_NARROW)
{
const UVec4 bitDepth (getBitDepth(format));
for (size_t xChromaOffsetNdx = 0; xChromaOffsetNdx < DE_LENGTH_OF_ARRAY(chromaLocations); xChromaOffsetNdx++)
for (size_t yChromaOffsetNdx = 0; yChromaOffsetNdx < DE_LENGTH_OF_ARRAY(chromaLocations); yChromaOffsetNdx++)
{
- const vk::VkChromaLocationKHR xChromaOffset (chromaLocations[xChromaOffsetNdx].value);
+ const vk::VkChromaLocation xChromaOffset (chromaLocations[xChromaOffsetNdx].value);
const char* const xChromaOffsetName (chromaLocations[xChromaOffsetNdx].name);
- const vk::VkChromaLocationKHR yChromaOffset (chromaLocations[yChromaOffsetNdx].value);
+ const vk::VkChromaLocation yChromaOffset (chromaLocations[yChromaOffsetNdx].value);
const char* const yChromaOffsetName (chromaLocations[yChromaOffsetNdx].name);
for (size_t tilingNdx = 0; tilingNdx < DE_LENGTH_OF_ARRAY(imageTilings); tilingNdx++)
const char* const tilingName (imageTilings[tilingNdx].name);
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, chromaLocation, chromaLocation, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, identitySwizzle);
{
const glu::ShaderType shaderType (rng.choose<glu::ShaderType>(DE_ARRAY_BEGIN(shaderTypes), DE_ARRAY_END(shaderTypes)));
- const vk::VkChromaLocationKHR chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
+ const vk::VkChromaLocation chromaLocation (rng.choose<ChromaLocationNamePair, const ChromaLocationNamePair*>(DE_ARRAY_BEGIN(chromaLocations), DE_ARRAY_END(chromaLocations)).value);
const TestConfig config (shaderType, format, tiling, textureFilter, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE, vk::VK_SAMPLER_ADDRESS_MODE_CLAMP_TO_EDGE,
vk::VK_FILTER_NEAREST, chromaLocation, chromaLocation, explicitReconstruction, disjoint,
defaultColorRange, defaultColorModel, swappedChromaSwizzle);
? properties.optimalTilingFeatures
: properties.linearTilingFeatures);
- if ((features & vk::VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR) == 0
- && (features & vk::VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR) == 0)
+ if ((features & vk::VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0
+ && (features & vk::VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0)
{
TCU_THROW(NotSupportedError, "Source format doesn't support copies");
}
- if (config.src.disjoint && ((features & vk::VK_FORMAT_FEATURE_DISJOINT_BIT_KHR) == 0))
+ if (config.src.disjoint && ((features & vk::VK_FORMAT_FEATURE_DISJOINT_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn'tsupport disjoint planes");
}
catch (const vk::Error& err)
? properties.optimalTilingFeatures
: properties.linearTilingFeatures);
- if ((features & vk::VK_FORMAT_FEATURE_TRANSFER_SRC_BIT_KHR) == 0
- && (features & vk::VK_FORMAT_FEATURE_TRANSFER_DST_BIT_KHR) == 0)
+ if ((features & vk::VK_FORMAT_FEATURE_TRANSFER_SRC_BIT) == 0
+ && (features & vk::VK_FORMAT_FEATURE_TRANSFER_DST_BIT) == 0)
{
TCU_THROW(NotSupportedError, "Source format doesn't support copies");
}
- if (config.dst.disjoint && ((features & vk::VK_FORMAT_FEATURE_DISJOINT_BIT_KHR) == 0))
+ if (config.dst.disjoint && ((features & vk::VK_FORMAT_FEATURE_DISJOINT_BIT) == 0))
TCU_THROW(NotSupportedError, "Format doesn't disjoint planes");
}
catch (const vk::Error& err)
{
vk::VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,
DE_NULL,
- disjoint ? (vk::VkImageCreateFlags)vk::VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (vk::VkImageCreateFlags)0u,
+ disjoint ? (vk::VkImageCreateFlags)vk::VK_IMAGE_CREATE_DISJOINT_BIT : (vk::VkImageCreateFlags)0u,
vk::VK_IMAGE_TYPE_2D,
format,
switch (format)
{
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
return vk::VK_FORMAT_R8_UNORM;
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
{
DE_ASSERT(planeNdx < 2);
return vk::VK_FORMAT_R8G8_UNORM;
}
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
return vk::VK_FORMAT_R8_UNORM;
- case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
{
DE_ASSERT(planeNdx < 2);
return vk::VK_FORMAT_R8G8_UNORM;
}
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
return vk::VK_FORMAT_R8_UNORM;
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- return vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ return vk::VK_FORMAT_R10X6_UNORM_PACK16;
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
{
DE_ASSERT(planeNdx < 2);
if (planeNdx == 0)
- return vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ return vk::VK_FORMAT_R10X6_UNORM_PACK16;
else
- return vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR;
+ return vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
}
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- return vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ return vk::VK_FORMAT_R10X6_UNORM_PACK16;
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
{
DE_ASSERT(planeNdx < 2);
if (planeNdx == 0)
- return vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ return vk::VK_FORMAT_R10X6_UNORM_PACK16;
else
- return vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR;
+ return vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
}
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
- return vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+ return vk::VK_FORMAT_R10X6_UNORM_PACK16;
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- return vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ return vk::VK_FORMAT_R12X4_UNORM_PACK16;
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
{
DE_ASSERT(planeNdx < 2);
if (planeNdx == 0)
- return vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ return vk::VK_FORMAT_R12X4_UNORM_PACK16;
else
- return vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR;
+ return vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
}
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- return vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ return vk::VK_FORMAT_R12X4_UNORM_PACK16;
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
{
DE_ASSERT(planeNdx < 2);
if (planeNdx == 0)
- return vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ return vk::VK_FORMAT_R12X4_UNORM_PACK16;
else
- return vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR;
+ return vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
}
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
- return vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
+ return vk::VK_FORMAT_R12X4_UNORM_PACK16;
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
return vk::VK_FORMAT_R16_UNORM;
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
{
DE_ASSERT(planeNdx < 2);
return vk::VK_FORMAT_R16G16_UNORM;
}
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
return vk::VK_FORMAT_R16_UNORM;
- case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
{
DE_ASSERT(planeNdx < 2);
return vk::VK_FORMAT_R16G16_UNORM;
}
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
return vk::VK_FORMAT_R16_UNORM;
default:
vk::VK_FORMAT_R16_UINT,
vk::VK_FORMAT_R16_SINT,
vk::VK_FORMAT_R16_SFLOAT,
- vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR,
- vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR
+ vk::VK_FORMAT_R10X6_UNORM_PACK16,
+ vk::VK_FORMAT_R12X4_UNORM_PACK16
};
const vk::VkFormat class24Bit[] =
{
vk::VK_FORMAT_R32_SFLOAT,
vk::VK_FORMAT_B10G11R11_UFLOAT_PACK32,
vk::VK_FORMAT_E5B9G9R9_UFLOAT_PACK32,
- vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
- vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR
+ vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+ vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16
};
const vk::VkFormat class48Bit[] =
{
{
switch (format)
{
- case vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
- case vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
- case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
- case vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
+ case vk::VK_FORMAT_G8B8G8R8_422_UNORM:
+ case vk::VK_FORMAT_B8G8R8G8_422_UNORM:
+ case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G16B16G16R16_422_UNORM:
+ case vk::VK_FORMAT_B16G16R16G16_422_UNORM:
return UVec2(2, 1);
default:
{
switch (format)
{
- case vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR:
- case vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR:
+ case vk::VK_FORMAT_B8G8R8G8_422_UNORM:
+ case vk::VK_FORMAT_G8B8G8R8_422_UNORM:
return 4u;
- case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR:
- case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR:
- case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR:
+ case vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_B16G16R16G16_422_UNORM:
+ case vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16:
+ case vk::VK_FORMAT_G16B16G16R16_422_UNORM:
+ case vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16:
+ case vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16:
case vk::VK_FORMAT_R16G16B16A16_UNORM:
return 4u * 2u;
- case vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR:
- case vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR:
+ case vk::VK_FORMAT_R10X6_UNORM_PACK16:
+ case vk::VK_FORMAT_R12X4_UNORM_PACK16:
return 2u;
- case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR:
- case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR:
+ case vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16:
+ case vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16:
return 2u * 2u;
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
return 3u * 2u;
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
- case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
DE_FATAL("Plane formats not supported");
return ~0u;
const vk::MemoryRequirement srcMemoryRequirement (config.src.tiling == vk::VK_IMAGE_TILING_OPTIMAL
? vk::MemoryRequirement::Any
: vk::MemoryRequirement::HostVisible);
- const vk::VkImageCreateFlags srcCreateFlags (config.src.disjoint ? vk::VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (vk::VkImageCreateFlagBits)0u);
+ const vk::VkImageCreateFlags srcCreateFlags (config.src.disjoint ? vk::VK_IMAGE_CREATE_DISJOINT_BIT : (vk::VkImageCreateFlagBits)0u);
const vector<AllocationSp> srcImageMemory (allocateAndBindImageMemory(vkd, device, context.getDefaultAllocator(), *srcImage, config.src.format, srcCreateFlags, srcMemoryRequirement));
const vk::Unique<vk::VkImage> dstImage (createImage(vkd, device, config.dst.format, config.dst.size, config.dst.disjoint, config.dst.tiling));
const vk::MemoryRequirement dstMemoryRequirement (config.dst.tiling == vk::VK_IMAGE_TILING_OPTIMAL
? vk::MemoryRequirement::Any
: vk::MemoryRequirement::HostVisible);
- const vk::VkImageCreateFlags dstCreateFlags (config.dst.disjoint ? vk::VK_IMAGE_CREATE_DISJOINT_BIT_KHR : (vk::VkImageCreateFlagBits)0u);
+ const vk::VkImageCreateFlags dstCreateFlags (config.dst.disjoint ? vk::VK_IMAGE_CREATE_DISJOINT_BIT : (vk::VkImageCreateFlagBits)0u);
const vector<AllocationSp> dstImageMemory (allocateAndBindImageMemory(vkd, device, context.getDefaultAllocator(), *dstImage, config.dst.format, dstCreateFlags, dstMemoryRequirement));
if (config.src.tiling == vk::VK_IMAGE_TILING_OPTIMAL)
vk::VK_FORMAT_R16G16B16_UNORM,
vk::VK_FORMAT_R16G16B16A16_UNORM,
vk::VK_FORMAT_B10G11R11_UFLOAT_PACK32,
- vk::VK_FORMAT_G8B8G8R8_422_UNORM_KHR,
- vk::VK_FORMAT_B8G8R8G8_422_UNORM_KHR,
- vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR,
- vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR,
- vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR,
- vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR,
- vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR,
- vk::VK_FORMAT_R10X6_UNORM_PACK16_KHR,
- vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR,
- vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_R12X4_UNORM_PACK16_KHR,
- vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR,
- vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR,
- vk::VK_FORMAT_G16B16G16R16_422_UNORM_KHR,
- vk::VK_FORMAT_B16G16R16G16_422_UNORM_KHR,
- vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR,
- vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR,
- vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR,
- vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR,
- vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR
+ vk::VK_FORMAT_G8B8G8R8_422_UNORM,
+ vk::VK_FORMAT_B8G8R8G8_422_UNORM,
+ vk::VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM,
+ vk::VK_FORMAT_G8_B8R8_2PLANE_420_UNORM,
+ vk::VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM,
+ vk::VK_FORMAT_G8_B8R8_2PLANE_422_UNORM,
+ vk::VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM,
+ vk::VK_FORMAT_R10X6_UNORM_PACK16,
+ vk::VK_FORMAT_R10X6G10X6_UNORM_2PACK16,
+ vk::VK_FORMAT_R10X6G10X6B10X6A10X6_UNORM_4PACK16,
+ vk::VK_FORMAT_G10X6B10X6G10X6R10X6_422_UNORM_4PACK16,
+ vk::VK_FORMAT_B10X6G10X6R10X6G10X6_422_UNORM_4PACK16,
+ vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16,
+ vk::VK_FORMAT_R12X4_UNORM_PACK16,
+ vk::VK_FORMAT_R12X4G12X4_UNORM_2PACK16,
+ vk::VK_FORMAT_R12X4G12X4B12X4A12X4_UNORM_4PACK16,
+ vk::VK_FORMAT_G12X4B12X4G12X4R12X4_422_UNORM_4PACK16,
+ vk::VK_FORMAT_B12X4G12X4R12X4G12X4_422_UNORM_4PACK16,
+ vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16,
+ vk::VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16,
+ vk::VK_FORMAT_G16B16G16R16_422_UNORM,
+ vk::VK_FORMAT_B16G16R16G16_422_UNORM,
+ vk::VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM,
+ vk::VK_FORMAT_G16_B16R16_2PLANE_420_UNORM,
+ vk::VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM,
+ vk::VK_FORMAT_G16_B16R16_2PLANE_422_UNORM,
+ vk::VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM
};
const struct
{
VkDevice device,
VkImage image,
VkFormat format,
- VkSamplerYcbcrConversionKHR conversion)
+ VkSamplerYcbcrConversion conversion)
{
- const VkSamplerYcbcrConversionInfoKHR conversionInfo =
+ const VkSamplerYcbcrConversionInfo conversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
conversion
};
const Unique<VkImage> image (createTestImage(vkd, device, format, size, createFlags, tiling, mappedMemory ? VK_IMAGE_LAYOUT_PREINITIALIZED : VK_IMAGE_LAYOUT_UNDEFINED));
const vector<AllocationSp> allocations (allocateAndBindImageMemory(vkd, device, context.getDefaultAllocator(), *image, format, createFlags, mappedMemory ? MemoryRequirement::HostVisible : MemoryRequirement::Any));
- const VkSamplerYcbcrConversionCreateInfoKHR conversionInfo =
+ const VkSamplerYcbcrConversionCreateInfo conversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
DE_NULL,
format,
- VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
- VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+ VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
{
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
},
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
+ VK_CHROMA_LOCATION_MIDPOINT,
+ VK_CHROMA_LOCATION_MIDPOINT,
VK_FILTER_NEAREST,
VK_FALSE, // forceExplicitReconstruction
};
- const Unique<VkSamplerYcbcrConversionKHR> conversion (createSamplerYcbcrConversionKHR(vkd, device, &conversionInfo));
+ const Unique<VkSamplerYcbcrConversion> conversion (createSamplerYcbcrConversion(vkd, device, &conversionInfo));
const Unique<VkImageView> imageView (createImageView(vkd, device, *image, format, *conversion));
- const VkSamplerYcbcrConversionInfoKHR samplerConversionInfo =
+ const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
*conversion,
};
addFunctionCaseWithPrograms(group, name, "", initPrograms, testFormat, TestParameters(format, size, 0u, tiling, shaderType, false));
if (getPlaneCount(format) > 1)
- addFunctionCaseWithPrograms(group, name + "_disjoint", "", initPrograms, testFormat, TestParameters(format, size, (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT_KHR, tiling, shaderType, false));
+ addFunctionCaseWithPrograms(group, name + "_disjoint", "", initPrograms, testFormat, TestParameters(format, size, (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT, tiling, shaderType, false));
if (tiling == VK_IMAGE_TILING_LINEAR)
{
addFunctionCaseWithPrograms(group, name + "_mapped", "", initPrograms, testFormat, TestParameters(format, size, 0u, tiling, shaderType, true));
if (getPlaneCount(format) > 1)
- addFunctionCaseWithPrograms(group, name + "_disjoint_mapped", "", initPrograms, testFormat, TestParameters(format, size, (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT_KHR, tiling, shaderType, true));
+ addFunctionCaseWithPrograms(group, name + "_disjoint_mapped", "", initPrograms, testFormat, TestParameters(format, size, (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT, tiling, shaderType, true));
}
}
}
const DeviceInterface& vkd = context.getDeviceInterface();
const VkDevice device = context.getDevice();
- const VkSamplerYcbcrConversionCreateInfoKHR conversionInfo =
+ const VkSamplerYcbcrConversionCreateInfo conversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
DE_NULL,
params.format,
- VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
- VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+ VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
{
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
},
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
+ VK_CHROMA_LOCATION_MIDPOINT,
+ VK_CHROMA_LOCATION_MIDPOINT,
VK_FILTER_NEAREST,
VK_FALSE, // forceExplicitReconstruction
};
- const Unique<VkSamplerYcbcrConversionKHR> conversion (isYCbCrImage
- ? createSamplerYcbcrConversionKHR(vkd, device, &conversionInfo)
- : Move<VkSamplerYcbcrConversionKHR>());
+ const Unique<VkSamplerYcbcrConversion> conversion (isYCbCrImage
+ ? createSamplerYcbcrConversion(vkd, device, &conversionInfo)
+ : Move<VkSamplerYcbcrConversion>());
- const VkSamplerYcbcrConversionInfoKHR samplerConversionInfo =
+ const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
*conversion,
};
const DeviceInterface& vkd = context.getDeviceInterface();
const VkDevice device = context.getDevice();
- const VkSamplerYcbcrConversionCreateInfoKHR conversionInfo =
+ const VkSamplerYcbcrConversionCreateInfo conversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
DE_NULL,
params.format,
- VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
- VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+ VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
{
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
},
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
+ VK_CHROMA_LOCATION_MIDPOINT,
+ VK_CHROMA_LOCATION_MIDPOINT,
VK_FILTER_NEAREST,
VK_FALSE, // forceExplicitReconstruction
};
- const Unique<VkSamplerYcbcrConversionKHR> conversion (isYCbCrImage
- ? createSamplerYcbcrConversionKHR(vkd, device, &conversionInfo)
- : Move<VkSamplerYcbcrConversionKHR>());
+ const Unique<VkSamplerYcbcrConversion> conversion (isYCbCrImage
+ ? createSamplerYcbcrConversion(vkd, device, &conversionInfo)
+ : Move<VkSamplerYcbcrConversion>());
- const VkSamplerYcbcrConversionInfoKHR samplerConversionInfo =
+ const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
*conversion,
};
std::string name = de::toLower(de::toString(params.format).substr(10));
const bool isLod = params.query == QUERY_TYPE_IMAGE_LOD;
- if ((params.flags & VK_IMAGE_CREATE_DISJOINT_BIT_KHR) != 0)
+ if ((params.flags & VK_IMAGE_CREATE_DISJOINT_BIT) != 0)
name += "_disjoint";
addFunctionCaseWithPrograms(group,
addImageQueryCase(group, TestParameters(params.query, format, 0u, params.shaderType));
if (getPlaneCount(format) > 1)
- addImageQueryCase(group, TestParameters(params.query, format, (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT_KHR, params.shaderType));
+ addImageQueryCase(group, TestParameters(params.query, format, (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT, params.shaderType));
}
}
void checkImageSupport (Context& context, VkFormat format, VkImageCreateFlags createFlags, VkImageTiling tiling)
{
- const bool disjoint = (createFlags & VK_IMAGE_CREATE_DISJOINT_BIT_KHR) != 0;
- const VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR* features = findStructure<VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR>(context.getDeviceFeatures2().pNext);
+ const bool disjoint = (createFlags & VK_IMAGE_CREATE_DISJOINT_BIT) != 0;
+ const VkPhysicalDeviceSamplerYcbcrConversionFeatures* features = findStructure<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(context.getDeviceFeatures2().pNext);
vector<string> reqExts;
reqExts.push_back("VK_KHR_sampler_ycbcr_conversion");
? formatProperties.optimalTilingFeatures
: formatProperties.linearTilingFeatures;
- if ((featureFlags & (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT_KHR | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT_KHR)) == 0)
+ if ((featureFlags & (VK_FORMAT_FEATURE_MIDPOINT_CHROMA_SAMPLES_BIT | VK_FORMAT_FEATURE_COSITED_CHROMA_SAMPLES_BIT)) == 0)
TCU_THROW(NotSupportedError, "YCbCr conversion is not supported for format");
- if (disjoint && ((featureFlags & VK_FORMAT_FEATURE_DISJOINT_BIT_KHR) == 0))
+ if (disjoint && ((featureFlags & VK_FORMAT_FEATURE_DISJOINT_BIT) == 0))
TCU_THROW(NotSupportedError, "Disjoint planes are not supported for format");
}
}
{
vector<AllocationSp> allocations;
- if ((createFlags & VK_IMAGE_CREATE_DISJOINT_BIT_KHR) != 0)
+ if ((createFlags & VK_IMAGE_CREATE_DISJOINT_BIT) != 0)
{
const deUint32 numPlanes = getPlaneCount(format);
{
switch (multiPlanarFormat)
{
- case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM_KHR:
- case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM_KHR:
- case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM_KHR:
+ case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM:
+ case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM:
+ case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM:
if (de::inRange(planeNdx, 0u, 2u))
return VK_FORMAT_R8_UNORM;
- case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM_KHR:
- case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM:
+ case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM:
if (planeNdx == 0)
return VK_FORMAT_R8_UNORM;
else if (planeNdx == 1)
return VK_FORMAT_R8G8_UNORM;
- case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16_KHR:
- case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16_KHR:
- case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16:
+ case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16:
if (de::inRange(planeNdx, 0u, 2u))
- return VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ return VK_FORMAT_R10X6_UNORM_PACK16;
- case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16_KHR:
- case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16:
if (planeNdx == 0)
- return VK_FORMAT_R10X6_UNORM_PACK16_KHR;
+ return VK_FORMAT_R10X6_UNORM_PACK16;
else if (planeNdx == 1)
- return VK_FORMAT_R10X6G10X6_UNORM_2PACK16_KHR;
+ return VK_FORMAT_R10X6G10X6_UNORM_2PACK16;
- case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16_KHR:
- case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16_KHR:
- case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16:
if (de::inRange(planeNdx, 0u, 2u))
- return VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ return VK_FORMAT_R12X4_UNORM_PACK16;
- case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16_KHR:
- case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16_KHR:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16:
+ case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16:
if (planeNdx == 0)
- return VK_FORMAT_R12X4_UNORM_PACK16_KHR;
+ return VK_FORMAT_R12X4_UNORM_PACK16;
else if (planeNdx == 1)
- return VK_FORMAT_R12X4G12X4_UNORM_2PACK16_KHR;
+ return VK_FORMAT_R12X4G12X4_UNORM_2PACK16;
- case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM_KHR:
- case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM_KHR:
- case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM_KHR:
+ case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM:
+ case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM:
+ case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM:
if (de::inRange(planeNdx, 0u, 2u))
return VK_FORMAT_R16_UNORM;
- case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM_KHR:
- case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM_KHR:
+ case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM:
+ case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM:
if (planeNdx == 0)
return VK_FORMAT_R16_UNORM;
else if (planeNdx == 1)
VkImage image,
VkFormat format,
VkImageAspectFlagBits imageAspect,
- VkSamplerYcbcrConversionKHR conversion)
+ VkSamplerYcbcrConversion conversion)
{
- const VkSamplerYcbcrConversionInfoKHR samplerConversionInfo =
+ const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
conversion
};
if (imageAlias)
VK_CHECK(vkd.bindImageMemory(device, *imageAlias, allocations[params.planeNdx]->getMemory(), allocations[params.planeNdx]->getOffset()));
- const VkSamplerYcbcrConversionCreateInfoKHR conversionInfo =
+ const VkSamplerYcbcrConversionCreateInfo conversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_CREATE_INFO,
DE_NULL,
format,
- VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY_KHR,
- VK_SAMPLER_YCBCR_RANGE_ITU_FULL_KHR,
+ VK_SAMPLER_YCBCR_MODEL_CONVERSION_RGB_IDENTITY,
+ VK_SAMPLER_YCBCR_RANGE_ITU_FULL,
{
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
VK_COMPONENT_SWIZZLE_IDENTITY,
},
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
- VK_CHROMA_LOCATION_MIDPOINT_KHR,
+ VK_CHROMA_LOCATION_MIDPOINT,
+ VK_CHROMA_LOCATION_MIDPOINT,
VK_FILTER_NEAREST,
VK_FALSE, // forceExplicitReconstruction
};
- const Unique<VkSamplerYcbcrConversionKHR> conversion (createSamplerYcbcrConversionKHR(vkd, device, &conversionInfo));
+ const Unique<VkSamplerYcbcrConversion> conversion (createSamplerYcbcrConversion(vkd, device, &conversionInfo));
const Unique<VkImageView> wholeView (createImageView(vkd, device, *image, format, VK_IMAGE_ASPECT_COLOR_BIT, *conversion));
const Unique<VkImageView> planeView (createImageView(vkd,
device,
!imageAlias ? getPlaneAspect(params.planeNdx) : VK_IMAGE_ASPECT_COLOR_BIT,
*conversion));
- const VkSamplerYcbcrConversionInfoKHR samplerConversionInfo =
+ const VkSamplerYcbcrConversionInfo samplerConversionInfo =
{
- VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO_KHR,
+ VK_STRUCTURE_TYPE_SAMPLER_YCBCR_CONVERSION_INFO,
DE_NULL,
*conversion,
};
- const VkSamplerCreateInfo wholeSamplerInfo =
+ const VkSamplerCreateInfo wholeSamplerInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
&samplerConversionInfo,
VK_BORDER_COLOR_FLOAT_TRANSPARENT_BLACK, // borderColor
VK_FALSE, // unnormalizedCoords
};
- const VkSamplerCreateInfo planeSamplerInfo =
+ const VkSamplerCreateInfo planeSamplerInfo =
{
VK_STRUCTURE_TYPE_SAMPLER_CREATE_INFO,
DE_NULL,
name << de::toLower(de::toString(params.format).substr(10));
if ((params.viewType != TestParameters::VIEWTYPE_MEMORY_ALIAS) &&
- ((params.createFlags & VK_IMAGE_CREATE_DISJOINT_BIT_KHR) != 0))
+ ((params.createFlags & VK_IMAGE_CREATE_DISJOINT_BIT) != 0))
name << "_disjoint";
name << "_plane_" << params.planeNdx;
const glu::ShaderType shaderType = glu::SHADERTYPE_FRAGMENT;
const UVec2 size (32, 58);
const VkImageCreateFlags baseFlags = (VkImageCreateFlags)VK_IMAGE_CREATE_MUTABLE_FORMAT_BIT
- | (viewType == TestParameters::VIEWTYPE_MEMORY_ALIAS ? (VkImageCreateFlags)VK_IMAGE_CREATE_ALIAS_BIT_KHR : 0u);
+ | (viewType == TestParameters::VIEWTYPE_MEMORY_ALIAS ? (VkImageCreateFlags)VK_IMAGE_CREATE_ALIAS_BIT : 0u);
for (int formatNdx = VK_YCBCR_FORMAT_FIRST; formatNdx < VK_YCBCR_FORMAT_LAST; formatNdx++)
{
for (int isDisjoint = 0; isDisjoint < 2; ++isDisjoint)
{
- const VkImageCreateFlags flags = baseFlags | (isDisjoint == 1 ? (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT_KHR : 0u);
+ const VkImageCreateFlags flags = baseFlags | (isDisjoint == 1 ? (VkImageCreateFlags)VK_IMAGE_CREATE_DISJOINT_BIT : 0u);
if ((viewType == TestParameters::VIEWTYPE_MEMORY_ALIAS) &&
- ((flags & VK_IMAGE_CREATE_DISJOINT_BIT_KHR) == 0))
+ ((flags & VK_IMAGE_CREATE_DISJOINT_BIT) == 0))
continue; // Memory alias cases require disjoint planes
for (deUint32 planeNdx = 0; planeNdx < numPlanes; ++planeNdx)
yield line
yield "};"
-def genCompositeTypeAliasSrc (type):
- yield "typedef %s %s;" % (type.name, type.alias.name)
-
def genHandlesSrc (handles):
uniqeHandles, duplicatedHandles = splitUniqueAndDuplicatedEntries(handles)
if not enum.isAlias:
for line in genEnumSrc(enum):
yield line
- if enum.alias != None:
- yield "typedef enum %s %s;" % (enum.name, enum.alias.name)
- for i, value in enumerate(enum.values):
- yield "#define "+enum.values[i][0] +"_KHR "+ enum.values[i][0]
yield ""
for bitfield in api.bitfields:
if not bitfield.isAlias:
for line in genBitfieldSrc(bitfield):
yield line
- if bitfield.alias != None:
- yield "typedef %s %s;" % (bitfield.name, bitfield.alias.name)
- if len(bitfield.values) > 0:
- yield "typedef %s %s;" % (getBitEnumNameForBitfield(bitfield.name), getBitEnumNameForBitfield(bitfield.alias.name))
- for i, value in enumerate(bitfield.values):
- yield "#define "+bitfield.values[i][0] +"_KHR "+ bitfield.values[i][0]
yield ""
for line in indentLines(["VK_DEFINE_PLATFORM_TYPE(%s,\t%s);" % (s[0], c) for n, s, c in PLATFORM_TYPES]):
yield line
if not type.isAlias:
for line in genCompositeTypeSrc(type):
yield line
- if type.alias != None:
- for line in genCompositeTypeAliasSrc(type):
- yield line
yield ""
writeInlFile(filename, INL_HEADER, gen())
for function in api.functions:
if not function.getType() in functionTypes:
continue
-
- yield "virtual %s\t%s\t(%s) const%s;" % (function.returnType, getInterfaceName(function), argListToStr(function.arguments), postfix)
+ if not function.isAlias:
+ yield "virtual %s\t%s\t(%s) const%s;" % (function.returnType, getInterfaceName(function), argListToStr(function.arguments), postfix)
writeInlFile(filename, INL_HEADER, indentLines(genProtos()))
def writeFuncPtrInterfaceImpl (api, filename, functionTypes, className):
def makeFuncPtrInterfaceImpl ():
- refFuncs = {}
- for f in api.functions:
- if not f.isAlias:
- refFuncs[f] = f
- if f.alias != None:
- refFuncs[f.alias] = f
for function in api.functions:
- if function.getType() in functionTypes:
+ if function.getType() in functionTypes and not function.isAlias:
yield ""
yield "%s %s::%s (%s) const" % (function.returnType, className, getInterfaceName(function), argListToStr(function.arguments))
yield "{"
yield " *pApiVersion = VK_API_VERSION_1_0;"
yield " return VK_SUCCESS;"
else:
- yield " %sm_vk.%s(%s);" % ("return " if function.returnType != "void" else "", getInterfaceName(refFuncs[function]), ", ".join(a.name for a in function.arguments))
+ yield " %sm_vk.%s(%s);" % ("return " if function.returnType != "void" else "", getInterfaceName(function), ", ".join(a.name for a in function.arguments))
yield "}"
writeInlFile(filename, INL_HEADER, makeFuncPtrInterfaceImpl())
yield "}"
for enum in api.enums:
+ if enum.isAlias:
+ continue
yield ""
yield "const char* get%sName (%s value)" % (enum.name[2:], enum.name)
yield "{"
yield "}"
for bitfield in api.bitfields:
+ if bitfield.isAlias:
+ continue
yield ""
yield "tcu::Format::Bitfield<32> get%sStr (%s value)" % (bitfield.name[2:], bitfield.name)
yield "{"
def getConstructorFunctions (api):
funcs = []
for function in api.functions:
+ if function.isAlias:
+ continue
if (function.name[:8] == "vkCreate" or function.name == "vkAllocateMemory") and not "createInfoCount" in [a.name for a in function.arguments]:
if function.name == "vkCreateDisplayModeKHR":
continue # No way to delete display modes (bug?)
def gen ():
for type in api.compositeTypes:
- if not isSimpleStruct(type):
+ if not isSimpleStruct(type) or type.isAlias:
continue
yield ""
void* pNext;
uint32_t externalFormat;
VkFormatFeatureFlags formatFeatures;
- VkSamplerYcbcrModelConversionKHR suggestedYcbcrModel;
- VkSamplerYcbcrRangeKHR suggestedYcbcrRange;
- VkChromaLocationKHR suggestedXChromaOffset;
- VkChromaLocationKHR suggestedYChromaOffset;
+ VkSamplerYcbcrModelConversion suggestedYcbcrModel;
+ VkSamplerYcbcrRange suggestedYcbcrRange;
+ VkChromaLocation suggestedXChromaOffset;
+ VkChromaLocation suggestedYChromaOffset;
} VkAndroidHardwareBufferExternalFormatPropertiesANDROID;
typedef VkSamplerYcbcrModelConversion VkSamplerYcbcrModelConversionKHR;
projects / platform / upstream / VK-GL-CTS.git / commitdiff