external/vulkancts/modules/vulkan/clipping/vktClippingUtil.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * Vulkan Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2016 The Khronos Group Inc.
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  *
  *//*!
  * \file
  * \brief Clipping tests utilities
  *//*--------------------------------------------------------------------*/

 #include "vktClippingUtil.hpp"
 #include "vkTypeUtil.hpp"

 namespace vkt
 {
 namespace clipping
 {
 using namespace vk;

 VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize			bufferSize,
 										 const VkBufferUsageFlags	usage)
 {
 	const VkBufferCreateInfo bufferCreateInfo =
 	{
 		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,	// VkStructureType		sType;
 		DE_NULL,								// const void*			pNext;
 		(VkBufferCreateFlags)0,					// VkBufferCreateFlags	flags;
 		bufferSize,								// VkDeviceSize			size;
 		usage,									// VkBufferUsageFlags	usage;
 		VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode		sharingMode;
 		0u,										// deUint32				queueFamilyIndexCount;
 		DE_NULL,								// const deUint32*		pQueueFamilyIndices;
 	};
 	return bufferCreateInfo;
 }

 VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags	srcAccessMask,
 											   const VkAccessFlags	dstAccessMask,
 											   const VkBuffer		buffer,
 											   const VkDeviceSize	offset,
 											   const VkDeviceSize	bufferSizeBytes)
 {
 	const VkBufferMemoryBarrier barrier =
 	{
 		VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,	// VkStructureType	sType;
 		DE_NULL,									// const void*		pNext;
 		srcAccessMask,								// VkAccessFlags	srcAccessMask;
 		dstAccessMask,								// VkAccessFlags	dstAccessMask;
 		VK_QUEUE_FAMILY_IGNORED,					// deUint32			srcQueueFamilyIndex;
 		VK_QUEUE_FAMILY_IGNORED,					// deUint32			destQueueFamilyIndex;
 		buffer,										// VkBuffer			buffer;
 		offset,										// VkDeviceSize		offset;
 		bufferSizeBytes,							// VkDeviceSize		size;
 	};
 	return barrier;
 }

 VkImageMemoryBarrier makeImageMemoryBarrier	(const VkAccessFlags			srcAccessMask,
 											 const VkAccessFlags			dstAccessMask,
 											 const VkImageLayout			oldLayout,
 											 const VkImageLayout			newLayout,
 											 const VkImage					image,
 											 const VkImageSubresourceRange	subresourceRange)
 {
 	const VkImageMemoryBarrier barrier =
 	{
 		VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER,			// VkStructureType			sType;
 		DE_NULL,										// const void*				pNext;
 		srcAccessMask,									// VkAccessFlags			outputMask;
 		dstAccessMask,									// VkAccessFlags			inputMask;
 		oldLayout,										// VkImageLayout			oldLayout;
 		newLayout,										// VkImageLayout			newLayout;
 		VK_QUEUE_FAMILY_IGNORED,						// deUint32					srcQueueFamilyIndex;
 		VK_QUEUE_FAMILY_IGNORED,						// deUint32					destQueueFamilyIndex;
 		image,											// VkImage					image;
 		subresourceRange,								// VkImageSubresourceRange	subresourceRange;
 	};
 	return barrier;
 }

 Move<VkCommandPool> makeCommandPool (const DeviceInterface& vk, const VkDevice device, const deUint32 queueFamilyIndex)
 {
 	const VkCommandPoolCreateInfo info =
 	{
 		VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO,			// VkStructureType			sType;
 		DE_NULL,											// const void*				pNext;
 		VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT,	// VkCommandPoolCreateFlags	flags;
 		queueFamilyIndex,									// deUint32					queueFamilyIndex;
 	};
 	return createCommandPool(vk, device, &info);
 }

 Move<VkCommandBuffer> makeCommandBuffer (const DeviceInterface& vk, const VkDevice device, const VkCommandPool commandPool)
 {
 	const VkCommandBufferAllocateInfo info =
 	{
 		VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO,		// VkStructureType		sType;
 		DE_NULL,											// const void*			pNext;
 		commandPool,										// VkCommandPool		commandPool;
 		VK_COMMAND_BUFFER_LEVEL_PRIMARY,					// VkCommandBufferLevel	level;
 		1u,													// deUint32				commandBufferCount;
 	};
 	return allocateCommandBuffer(vk, device, &info);
 }

 Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface&			vk,
 										 const VkDevice					device,
 										 const VkDescriptorPool			descriptorPool,
 										 const VkDescriptorSetLayout	setLayout)
 {
 	const VkDescriptorSetAllocateInfo info =
 	{
 		VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO,		// VkStructureType				sType;
 		DE_NULL,											// const void*					pNext;
 		descriptorPool,										// VkDescriptorPool				descriptorPool;
 		1u,													// deUint32						descriptorSetCount;
 		&setLayout,											// const VkDescriptorSetLayout*	pSetLayouts;
 	};
 	return allocateDescriptorSet(vk, device, &info);
 }

 Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface&		vk,
 										   const VkDevice				device,
 										   const VkDescriptorSetLayout	descriptorSetLayout)
 {
 	const VkPipelineLayoutCreateInfo info =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,		// VkStructureType				sType;
 		DE_NULL,											// const void*					pNext;
 		(VkPipelineLayoutCreateFlags)0,						// VkPipelineLayoutCreateFlags	flags;
 		1u,													// deUint32						setLayoutCount;
 		&descriptorSetLayout,								// const VkDescriptorSetLayout*	pSetLayouts;
 		0u,													// deUint32						pushConstantRangeCount;
 		DE_NULL,											// const VkPushConstantRange*	pPushConstantRanges;
 	};
 	return createPipelineLayout(vk, device, &info);
 }

 Move<VkPipelineLayout> makePipelineLayoutWithoutDescriptors (const DeviceInterface&		vk,
 															 const VkDevice				device)
 {
 	const VkPipelineLayoutCreateInfo info =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,		// VkStructureType				sType;
 		DE_NULL,											// const void*					pNext;
 		(VkPipelineLayoutCreateFlags)0,						// VkPipelineLayoutCreateFlags	flags;
 		0u,													// deUint32						setLayoutCount;
 		DE_NULL,											// const VkDescriptorSetLayout*	pSetLayouts;
 		0u,													// deUint32						pushConstantRangeCount;
 		DE_NULL,											// const VkPushConstantRange*	pPushConstantRanges;
 	};
 	return createPipelineLayout(vk, device, &info);
 }

 Move<VkImageView> makeImageView (const DeviceInterface&			vk,
 								 const VkDevice					device,
 								 const VkImage					image,
 								 const VkImageViewType			viewType,
 								 const VkFormat					format,
 								 const VkImageSubresourceRange	subresourceRange)
 {
 	const VkImageViewCreateInfo imageViewParams =
 	{
 		VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO,		// VkStructureType			sType;
 		DE_NULL,										// const void*				pNext;
 		(VkImageViewCreateFlags)0,						// VkImageViewCreateFlags	flags;
 		image,											// VkImage					image;
 		viewType,										// VkImageViewType			viewType;
 		format,											// VkFormat					format;
 		makeComponentMappingRGBA(),						// VkComponentMapping		components;
 		subresourceRange,								// VkImageSubresourceRange	subresourceRange;
 	};
 	return createImageView(vk, device, &imageViewParams);
 }

 VkBufferImageCopy makeBufferImageCopy (const VkImageSubresourceLayers	subresourceLayers,
 									   const VkExtent3D					extent)
 {
 	const VkBufferImageCopy copyParams =
 	{
 		0ull,										//	VkDeviceSize				bufferOffset;
 		0u,											//	deUint32					bufferRowLength;
 		0u,											//	deUint32					bufferImageHeight;
 		subresourceLayers,							//	VkImageSubresourceLayers	imageSubresource;
 		makeOffset3D(0, 0, 0),						//	VkOffset3D					imageOffset;
 		extent,										//	VkExtent3D					imageExtent;
 	};
 	return copyParams;
 }

 void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 {
 	const VkCommandBufferBeginInfo info =
 	{
 		VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO,	// VkStructureType                          sType;
 		DE_NULL,										// const void*                              pNext;
 		VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT,	// VkCommandBufferUsageFlags                flags;
 		DE_NULL,										// const VkCommandBufferInheritanceInfo*    pInheritanceInfo;
 	};
 	VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
 }

 void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
 {
 	VK_CHECK(vk.endCommandBuffer(commandBuffer));
 }

 void submitCommandsAndWait (const DeviceInterface&	vk,
 							const VkDevice			device,
 							const VkQueue			queue,
 							const VkCommandBuffer	commandBuffer)
 {
 	const VkFenceCreateInfo fenceInfo =
 	{
 		VK_STRUCTURE_TYPE_FENCE_CREATE_INFO,	// VkStructureType		sType;
 		DE_NULL,								// const void*			pNext;
 		(VkFenceCreateFlags)0,					// VkFenceCreateFlags	flags;
 	};
 	const Unique<VkFence> fence(createFence(vk, device, &fenceInfo));

 	const VkSubmitInfo submitInfo =
 	{
 		VK_STRUCTURE_TYPE_SUBMIT_INFO,		// VkStructureType                sType;
 		DE_NULL,							// const void*                    pNext;
 		0u,									// uint32_t                       waitSemaphoreCount;
 		DE_NULL,							// const VkSemaphore*             pWaitSemaphores;
 		DE_NULL,							// const VkPipelineStageFlags*    pWaitDstStageMask;
 		1u,									// uint32_t                       commandBufferCount;
 		&commandBuffer,						// const VkCommandBuffer*         pCommandBuffers;
 		0u,									// uint32_t                       signalSemaphoreCount;
 		DE_NULL,							// const VkSemaphore*             pSignalSemaphores;
 	};
 	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
 	VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
 }

 void requireFeatures (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const FeatureFlags flags)
 {
 	const VkPhysicalDeviceFeatures features = getPhysicalDeviceFeatures(vki, physDevice);

 	if (((flags & FEATURE_TESSELLATION_SHADER) != 0) && !features.tessellationShader)
 		throw tcu::NotSupportedError("Tessellation shader not supported");

 	if (((flags & FEATURE_GEOMETRY_SHADER) != 0) && !features.geometryShader)
 		throw tcu::NotSupportedError("Geometry shader not supported");

 	if (((flags & FEATURE_SHADER_FLOAT_64) != 0) && !features.shaderFloat64)
 		throw tcu::NotSupportedError("Double-precision floats not supported");

 	if (((flags & FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS) != 0) && !features.vertexPipelineStoresAndAtomics)
 		throw tcu::NotSupportedError("SSBO and image writes not supported in vertex pipeline");

 	if (((flags & FEATURE_FRAGMENT_STORES_AND_ATOMICS) != 0) && !features.fragmentStoresAndAtomics)
 		throw tcu::NotSupportedError("SSBO and image writes not supported in fragment shader");

 	if (((flags & FEATURE_SHADER_TESSELLATION_AND_GEOMETRY_POINT_SIZE) != 0) && !features.shaderTessellationAndGeometryPointSize)
 		throw tcu::NotSupportedError("Tessellation and geometry shaders don't support PointSize built-in");

 	if (((flags & FEATURE_DEPTH_CLAMP) != 0) && !features.depthClamp)
 		throw tcu::NotSupportedError("Depth clamp not supported");

 	if (((flags & FEATURE_LARGE_POINTS) != 0) && !features.largePoints)
 		throw tcu::NotSupportedError("Large points not supported");

 	if (((flags & FEATURE_WIDE_LINES) != 0) && !features.wideLines)
 		throw tcu::NotSupportedError("Wide lines not supported");

 	if (((flags & FEATURE_SHADER_CLIP_DISTANCE) != 0) && !features.shaderClipDistance)
 		throw tcu::NotSupportedError("Shader ClipDistance not supported");

 	if (((flags & FEATURE_SHADER_CULL_DISTANCE) != 0) && !features.shaderCullDistance)
 		throw tcu::NotSupportedError("Shader CullDistance not supported");
 }

 std::string getPrimitiveTopologyShortName (const VkPrimitiveTopology topology)
 {
 	std::string name(getPrimitiveTopologyName(topology));
 	return de::toLower(name.substr(22));
 }

 } // clipping
 } // vkt
	/*------------------------------------------------------------------------
	* Vulkan Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2016 The Khronos Group Inc.
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*
	//!
	* \file
	* \brief Clipping tests utilities
	//--------------------------------------------------------------------*/

	#include "vktClippingUtil.hpp"
	#include "vkTypeUtil.hpp"

	namespace vkt
	{
	namespace clipping
	{
	using namespace vk;

	VkBufferCreateInfo makeBufferCreateInfo (const VkDeviceSize bufferSize,
	const VkBufferUsageFlags usage)
	{
	const VkBufferCreateInfo bufferCreateInfo =
	{
	VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkBufferCreateFlags)0, // VkBufferCreateFlags flags;
	bufferSize, // VkDeviceSize size;
	usage, // VkBufferUsageFlags usage;
	VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
	0u, // deUint32 queueFamilyIndexCount;
	DE_NULL, // const deUint32* pQueueFamilyIndices;
	};
	return bufferCreateInfo;
	}

	VkBufferMemoryBarrier makeBufferMemoryBarrier (const VkAccessFlags srcAccessMask,
	const VkAccessFlags dstAccessMask,
	const VkBuffer buffer,
	const VkDeviceSize offset,
	const VkDeviceSize bufferSizeBytes)
	{
	const VkBufferMemoryBarrier barrier =
	{
	VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	srcAccessMask, // VkAccessFlags srcAccessMask;
	dstAccessMask, // VkAccessFlags dstAccessMask;
	VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
	VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
	buffer, // VkBuffer buffer;
	offset, // VkDeviceSize offset;
	bufferSizeBytes, // VkDeviceSize size;
	};
	return barrier;
	}

	VkImageMemoryBarrier makeImageMemoryBarrier (const VkAccessFlags srcAccessMask,
	const VkAccessFlags dstAccessMask,
	const VkImageLayout oldLayout,
	const VkImageLayout newLayout,
	const VkImage image,
	const VkImageSubresourceRange subresourceRange)
	{
	const VkImageMemoryBarrier barrier =
	{
	VK_STRUCTURE_TYPE_IMAGE_MEMORY_BARRIER, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	srcAccessMask, // VkAccessFlags outputMask;
	dstAccessMask, // VkAccessFlags inputMask;
	oldLayout, // VkImageLayout oldLayout;
	newLayout, // VkImageLayout newLayout;
	VK_QUEUE_FAMILY_IGNORED, // deUint32 srcQueueFamilyIndex;
	VK_QUEUE_FAMILY_IGNORED, // deUint32 destQueueFamilyIndex;
	image, // VkImage image;
	subresourceRange, // VkImageSubresourceRange subresourceRange;
	};
	return barrier;
	}

	Move<VkCommandPool> makeCommandPool (const DeviceInterface& vk, const VkDevice device, const deUint32 queueFamilyIndex)
	{
	const VkCommandPoolCreateInfo info =
	{
	VK_STRUCTURE_TYPE_COMMAND_POOL_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, // VkCommandPoolCreateFlags flags;
	queueFamilyIndex, // deUint32 queueFamilyIndex;
	};
	return createCommandPool(vk, device, &info);
	}

	Move<VkCommandBuffer> makeCommandBuffer (const DeviceInterface& vk, const VkDevice device, const VkCommandPool commandPool)
	{
	const VkCommandBufferAllocateInfo info =
	{
	VK_STRUCTURE_TYPE_COMMAND_BUFFER_ALLOCATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	commandPool, // VkCommandPool commandPool;
	VK_COMMAND_BUFFER_LEVEL_PRIMARY, // VkCommandBufferLevel level;
	1u, // deUint32 commandBufferCount;
	};
	return allocateCommandBuffer(vk, device, &info);
	}

	Move<VkDescriptorSet> makeDescriptorSet (const DeviceInterface& vk,
	const VkDevice device,
	const VkDescriptorPool descriptorPool,
	const VkDescriptorSetLayout setLayout)
	{
	const VkDescriptorSetAllocateInfo info =
	{
	VK_STRUCTURE_TYPE_DESCRIPTOR_SET_ALLOCATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	descriptorPool, // VkDescriptorPool descriptorPool;
	1u, // deUint32 descriptorSetCount;
	&setLayout, // const VkDescriptorSetLayout* pSetLayouts;
	};
	return allocateDescriptorSet(vk, device, &info);
	}

	Move<VkPipelineLayout> makePipelineLayout (const DeviceInterface& vk,
	const VkDevice device,
	const VkDescriptorSetLayout descriptorSetLayout)
	{
	const VkPipelineLayoutCreateInfo info =
	{
	VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
	1u, // deUint32 setLayoutCount;
	&descriptorSetLayout, // const VkDescriptorSetLayout* pSetLayouts;
	0u, // deUint32 pushConstantRangeCount;
	DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
	};
	return createPipelineLayout(vk, device, &info);
	}

	Move<VkPipelineLayout> makePipelineLayoutWithoutDescriptors (const DeviceInterface& vk,
	const VkDevice device)
	{
	const VkPipelineLayoutCreateInfo info =
	{
	VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineLayoutCreateFlags)0, // VkPipelineLayoutCreateFlags flags;
	0u, // deUint32 setLayoutCount;
	DE_NULL, // const VkDescriptorSetLayout* pSetLayouts;
	0u, // deUint32 pushConstantRangeCount;
	DE_NULL, // const VkPushConstantRange* pPushConstantRanges;
	};
	return createPipelineLayout(vk, device, &info);
	}

	Move<VkImageView> makeImageView (const DeviceInterface& vk,
	const VkDevice device,
	const VkImage image,
	const VkImageViewType viewType,
	const VkFormat format,
	const VkImageSubresourceRange subresourceRange)
	{
	const VkImageViewCreateInfo imageViewParams =
	{
	VK_STRUCTURE_TYPE_IMAGE_VIEW_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkImageViewCreateFlags)0, // VkImageViewCreateFlags flags;
	image, // VkImage image;
	viewType, // VkImageViewType viewType;
	format, // VkFormat format;
	makeComponentMappingRGBA(), // VkComponentMapping components;
	subresourceRange, // VkImageSubresourceRange subresourceRange;
	};
	return createImageView(vk, device, &imageViewParams);
	}

	VkBufferImageCopy makeBufferImageCopy (const VkImageSubresourceLayers subresourceLayers,
	const VkExtent3D extent)
	{
	const VkBufferImageCopy copyParams =
	{
	0ull, // VkDeviceSize bufferOffset;
	0u, // deUint32 bufferRowLength;
	0u, // deUint32 bufferImageHeight;
	subresourceLayers, // VkImageSubresourceLayers imageSubresource;
	makeOffset3D(0, 0, 0), // VkOffset3D imageOffset;
	extent, // VkExtent3D imageExtent;
	};
	return copyParams;
	}

	void beginCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
	{
	const VkCommandBufferBeginInfo info =
	{
	VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT, // VkCommandBufferUsageFlags flags;
	DE_NULL, // const VkCommandBufferInheritanceInfo* pInheritanceInfo;
	};
	VK_CHECK(vk.beginCommandBuffer(commandBuffer, &info));
	}

	void endCommandBuffer (const DeviceInterface& vk, const VkCommandBuffer commandBuffer)
	{
	VK_CHECK(vk.endCommandBuffer(commandBuffer));
	}

	void submitCommandsAndWait (const DeviceInterface& vk,
	const VkDevice device,
	const VkQueue queue,
	const VkCommandBuffer commandBuffer)
	{
	const VkFenceCreateInfo fenceInfo =
	{
	VK_STRUCTURE_TYPE_FENCE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkFenceCreateFlags)0, // VkFenceCreateFlags flags;
	};
	const Unique<VkFence> fence(createFence(vk, device, &fenceInfo));

	const VkSubmitInfo submitInfo =
	{
	VK_STRUCTURE_TYPE_SUBMIT_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	0u, // uint32_t waitSemaphoreCount;
	DE_NULL, // const VkSemaphore* pWaitSemaphores;
	DE_NULL, // const VkPipelineStageFlags* pWaitDstStageMask;
	1u, // uint32_t commandBufferCount;
	&commandBuffer, // const VkCommandBuffer* pCommandBuffers;
	0u, // uint32_t signalSemaphoreCount;
	DE_NULL, // const VkSemaphore* pSignalSemaphores;
	};
	VK_CHECK(vk.queueSubmit(queue, 1u, &submitInfo, *fence));
	VK_CHECK(vk.waitForFences(device, 1u, &fence.get(), DE_TRUE, ~0ull));
	}

	void requireFeatures (const InstanceInterface& vki, const VkPhysicalDevice physDevice, const FeatureFlags flags)
	{
	const VkPhysicalDeviceFeatures features = getPhysicalDeviceFeatures(vki, physDevice);

	if (((flags & FEATURE_TESSELLATION_SHADER) != 0) && !features.tessellationShader)
	throw tcu::NotSupportedError("Tessellation shader not supported");

	if (((flags & FEATURE_GEOMETRY_SHADER) != 0) && !features.geometryShader)
	throw tcu::NotSupportedError("Geometry shader not supported");

	if (((flags & FEATURE_SHADER_FLOAT_64) != 0) && !features.shaderFloat64)
	throw tcu::NotSupportedError("Double-precision floats not supported");

	if (((flags & FEATURE_VERTEX_PIPELINE_STORES_AND_ATOMICS) != 0) && !features.vertexPipelineStoresAndAtomics)
	throw tcu::NotSupportedError("SSBO and image writes not supported in vertex pipeline");

	if (((flags & FEATURE_FRAGMENT_STORES_AND_ATOMICS) != 0) && !features.fragmentStoresAndAtomics)
	throw tcu::NotSupportedError("SSBO and image writes not supported in fragment shader");

	if (((flags & FEATURE_SHADER_TESSELLATION_AND_GEOMETRY_POINT_SIZE) != 0) && !features.shaderTessellationAndGeometryPointSize)
	throw tcu::NotSupportedError("Tessellation and geometry shaders don't support PointSize built-in");

	if (((flags & FEATURE_DEPTH_CLAMP) != 0) && !features.depthClamp)
	throw tcu::NotSupportedError("Depth clamp not supported");

	if (((flags & FEATURE_LARGE_POINTS) != 0) && !features.largePoints)
	throw tcu::NotSupportedError("Large points not supported");

	if (((flags & FEATURE_WIDE_LINES) != 0) && !features.wideLines)
	throw tcu::NotSupportedError("Wide lines not supported");

	if (((flags & FEATURE_SHADER_CLIP_DISTANCE) != 0) && !features.shaderClipDistance)
	throw tcu::NotSupportedError("Shader ClipDistance not supported");

	if (((flags & FEATURE_SHADER_CULL_DISTANCE) != 0) && !features.shaderCullDistance)
	throw tcu::NotSupportedError("Shader CullDistance not supported");
	}

	std::string getPrimitiveTopologyShortName (const VkPrimitiveTopology topology)
	{
	std::string name(getPrimitiveTopologyName(topology));
	return de::toLower(name.substr(22));
	}

	} // clipping
	} // vkt