external/vulkancts/modules/vulkan/pipeline/vktPipelineSpecConstantUtil.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 Pipeline specialization constants test utilities
  *//*--------------------------------------------------------------------*/

 #include "vktPipelineSpecConstantUtil.hpp"
 #include "vkTypeUtil.hpp"
 #include <vector>

 namespace vkt
 {
 namespace pipeline
 {
 using namespace vk;

 GraphicsPipelineBuilder& GraphicsPipelineBuilder::setShader (const DeviceInterface&			vk,
 															 const VkDevice					device,
 															 const VkShaderStageFlagBits	stage,
 															 const ProgramBinary&			binary,
 															 const VkSpecializationInfo*	specInfo)
 {
 	VkShaderModule module;
 	switch (stage)
 	{
 		case (VK_SHADER_STAGE_VERTEX_BIT):
 			DE_ASSERT(m_vertexShaderModule.get() == DE_NULL);
 			m_vertexShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
 			module = *m_vertexShaderModule;
 			break;

 		case (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT):
 			DE_ASSERT(m_tessControlShaderModule.get() == DE_NULL);
 			m_tessControlShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
 			module = *m_tessControlShaderModule;
 			break;

 		case (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT):
 			DE_ASSERT(m_tessEvaluationShaderModule.get() == DE_NULL);
 			m_tessEvaluationShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
 			module = *m_tessEvaluationShaderModule;
 			break;

 		case (VK_SHADER_STAGE_GEOMETRY_BIT):
 			DE_ASSERT(m_geometryShaderModule.get() == DE_NULL);
 			m_geometryShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
 			module = *m_geometryShaderModule;
 			break;

 		case (VK_SHADER_STAGE_FRAGMENT_BIT):
 			DE_ASSERT(m_fragmentShaderModule.get() == DE_NULL);
 			m_fragmentShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
 			module = *m_fragmentShaderModule;
 			break;

 		default:
 			DE_FATAL("Invalid shader stage");
 			return *this;
 	}

 	const VkPipelineShaderStageCreateInfo pipelineShaderStageInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO,	// VkStructureType						sType;
 		DE_NULL,												// const void*							pNext;
 		(VkPipelineShaderStageCreateFlags)0,					// VkPipelineShaderStageCreateFlags		flags;
 		stage,													// VkShaderStageFlagBits				stage;
 		module,													// VkShaderModule						module;
 		"main",													// const char*							pName;
 		specInfo,												// const VkSpecializationInfo*			pSpecializationInfo;
 	};

 	m_shaderStageFlags |= stage;
 	m_shaderStages.push_back(pipelineShaderStageInfo);

 	return *this;
 }

 Move<VkPipeline> GraphicsPipelineBuilder::build (const DeviceInterface&	vk,
 												 const VkDevice			device,
 												 const VkPipelineLayout	pipelineLayout,
 												 const VkRenderPass		renderPass)
 {
 	const VkVertexInputBindingDescription vertexInputBindingDescription =
 	{
 		0u,								// uint32_t				binding;
 		sizeof(tcu::Vec4),				// uint32_t				stride;		// Vertex is a 4-element vector XYZW, position only
 		VK_VERTEX_INPUT_RATE_VERTEX,	// VkVertexInputRate	inputRate;
 	};

 	const VkVertexInputAttributeDescription vertexInputAttributeDescription =
 	{
 		0u,									// uint32_t			location;
 		0u,									// uint32_t			binding;
 		VK_FORMAT_R32G32B32A32_SFLOAT,		// VkFormat			format;
 		0u,									// uint32_t			offset;
 	};

 	const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,	// VkStructureType                             sType;
 		DE_NULL,													// const void*                                 pNext;
 		(VkPipelineVertexInputStateCreateFlags)0,					// VkPipelineVertexInputStateCreateFlags       flags;
 		1u,															// uint32_t                                    vertexBindingDescriptionCount;
 		&vertexInputBindingDescription,								// const VkVertexInputBindingDescription*      pVertexBindingDescriptions;
 		1u,															// uint32_t                                    vertexAttributeDescriptionCount;
 		&vertexInputAttributeDescription,							// const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions;
 	};

 	const VkPrimitiveTopology topology = (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
 	const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO,	// VkStructureType                             sType;
 		DE_NULL,														// const void*                                 pNext;
 		(VkPipelineInputAssemblyStateCreateFlags)0,						// VkPipelineInputAssemblyStateCreateFlags     flags;
 		topology,														// VkPrimitiveTopology                         topology;
 		VK_FALSE,														// VkBool32                                    primitiveRestartEnable;
 	};

 	const VkPipelineTessellationStateCreateInfo pipelineTessellationStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO,		// VkStructureType                             sType;
 		DE_NULL,														// const void*                                 pNext;
 		(VkPipelineTessellationStateCreateFlags)0,						// VkPipelineTessellationStateCreateFlags      flags;
 		3u,																// uint32_t                                    patchControlPoints;
 	};

 	const VkViewport	viewport	= makeViewport(m_renderSize);
 	const VkRect2D		scissor		= makeRect2D(m_renderSize);

 	const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO,	// VkStructureType                             sType;
 		DE_NULL,												// const void*                                 pNext;
 		(VkPipelineViewportStateCreateFlags)0,					// VkPipelineViewportStateCreateFlags          flags;
 		1u,														// uint32_t                                    viewportCount;
 		&viewport,												// const VkViewport*                           pViewports;
 		1u,														// uint32_t                                    scissorCount;
 		&scissor,												// const VkRect2D*                             pScissors;
 	};

 	const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO,		// VkStructureType                          sType;
 		DE_NULL,														// const void*                              pNext;
 		(VkPipelineRasterizationStateCreateFlags)0,						// VkPipelineRasterizationStateCreateFlags  flags;
 		VK_FALSE,														// VkBool32                                 depthClampEnable;
 		VK_FALSE,														// VkBool32                                 rasterizerDiscardEnable;
 		VK_POLYGON_MODE_FILL,											// VkPolygonMode							polygonMode;
 		VK_CULL_MODE_NONE,												// VkCullModeFlags							cullMode;
 		VK_FRONT_FACE_COUNTER_CLOCKWISE,								// VkFrontFace								frontFace;
 		VK_FALSE,														// VkBool32									depthBiasEnable;
 		0.0f,															// float									depthBiasConstantFactor;
 		0.0f,															// float									depthBiasClamp;
 		0.0f,															// float									depthBiasSlopeFactor;
 		1.0f,															// float									lineWidth;
 	};

 	const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO,	// VkStructureType							sType;
 		DE_NULL,													// const void*								pNext;
 		(VkPipelineMultisampleStateCreateFlags)0,					// VkPipelineMultisampleStateCreateFlags	flags;
 		VK_SAMPLE_COUNT_1_BIT,										// VkSampleCountFlagBits					rasterizationSamples;
 		VK_FALSE,													// VkBool32									sampleShadingEnable;
 		0.0f,														// float									minSampleShading;
 		DE_NULL,													// const VkSampleMask*						pSampleMask;
 		VK_FALSE,													// VkBool32									alphaToCoverageEnable;
 		VK_FALSE													// VkBool32									alphaToOneEnable;
 	};

 	const VkStencilOpState stencilOpStateBasic = makeStencilOpState(
 		VK_STENCIL_OP_KEEP,		// stencil fail
 		VK_STENCIL_OP_KEEP,		// depth & stencil pass
 		VK_STENCIL_OP_KEEP,		// depth only fail
 		VK_COMPARE_OP_NEVER,	// compare op
 		0u,						// compare mask
 		0u,						// write mask
 		0u);					// reference

 	VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,	// VkStructureType							sType;
 		DE_NULL,													// const void*								pNext;
 		(VkPipelineDepthStencilStateCreateFlags)0,					// VkPipelineDepthStencilStateCreateFlags	flags;
 		VK_FALSE,													// VkBool32									depthTestEnable;
 		VK_FALSE,													// VkBool32									depthWriteEnable;
 		VK_COMPARE_OP_LESS,											// VkCompareOp								depthCompareOp;
 		VK_FALSE,													// VkBool32									depthBoundsTestEnable;
 		VK_FALSE,													// VkBool32									stencilTestEnable;
 		stencilOpStateBasic,										// VkStencilOpState							front;
 		stencilOpStateBasic,										// VkStencilOpState							back;
 		0.0f,														// float									minDepthBounds;
 		1.0f,														// float									maxDepthBounds;
 	};

 	const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT | VK_COLOR_COMPONENT_G_BIT | VK_COLOR_COMPONENT_B_BIT | VK_COLOR_COMPONENT_A_BIT;
 	const VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState =
 	{
 		VK_FALSE,							// VkBool32					blendEnable;
 		VK_BLEND_FACTOR_ONE,				// VkBlendFactor			srcColorBlendFactor;
 		VK_BLEND_FACTOR_ZERO,				// VkBlendFactor			dstColorBlendFactor;
 		VK_BLEND_OP_ADD,					// VkBlendOp				colorBlendOp;
 		VK_BLEND_FACTOR_ONE,				// VkBlendFactor			srcAlphaBlendFactor;
 		VK_BLEND_FACTOR_ZERO,				// VkBlendFactor			dstAlphaBlendFactor;
 		VK_BLEND_OP_ADD,					// VkBlendOp				alphaBlendOp;
 		colorComponentsAll,					// VkColorComponentFlags	colorWriteMask;
 	};

 	const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
 	{
 		VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO,	// VkStructureType								sType;
 		DE_NULL,													// const void*									pNext;
 		(VkPipelineColorBlendStateCreateFlags)0,					// VkPipelineColorBlendStateCreateFlags			flags;
 		VK_FALSE,													// VkBool32										logicOpEnable;
 		VK_LOGIC_OP_COPY,											// VkLogicOp									logicOp;
 		1u,															// deUint32										attachmentCount;
 		&pipelineColorBlendAttachmentState,							// const VkPipelineColorBlendAttachmentState*	pAttachments;
 		{ 0.0f, 0.0f, 0.0f, 0.0f },									// float										blendConstants[4];
 	};

 	const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
 	{
 		VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO,	// VkStructureType									sType;
 		DE_NULL,											// const void*										pNext;
 		(VkPipelineCreateFlags)0,							// VkPipelineCreateFlags							flags;
 		static_cast<deUint32>(m_shaderStages.size()),		// deUint32											stageCount;
 		&m_shaderStages[0],									// const VkPipelineShaderStageCreateInfo*			pStages;
 		&vertexInputStateInfo,								// const VkPipelineVertexInputStateCreateInfo*		pVertexInputState;
 		&pipelineInputAssemblyStateInfo,					// const VkPipelineInputAssemblyStateCreateInfo*	pInputAssemblyState;
 		(m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ? &pipelineTessellationStateInfo : DE_NULL), // const VkPipelineTessellationStateCreateInfo*		pTessellationState;
 		&pipelineViewportStateInfo,							// const VkPipelineViewportStateCreateInfo*			pViewportState;
 		&pipelineRasterizationStateInfo,					// const VkPipelineRasterizationStateCreateInfo*	pRasterizationState;
 		&pipelineMultisampleStateInfo,						// const VkPipelineMultisampleStateCreateInfo*		pMultisampleState;
 		&pipelineDepthStencilStateInfo,						// const VkPipelineDepthStencilStateCreateInfo*		pDepthStencilState;
 		&pipelineColorBlendStateInfo,						// const VkPipelineColorBlendStateCreateInfo*		pColorBlendState;
 		DE_NULL,											// const VkPipelineDynamicStateCreateInfo*			pDynamicState;
 		pipelineLayout,										// VkPipelineLayout									layout;
 		renderPass,											// VkRenderPass										renderPass;
 		0u,													// deUint32											subpass;
 		DE_NULL,											// VkPipeline										basePipelineHandle;
 		0,													// deInt32											basePipelineIndex;
 	};

 	return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
 }

 VkImageCreateInfo makeImageCreateInfo (const tcu::IVec2& size, const VkFormat format, const VkImageUsageFlags usage)
 {
 	const VkImageCreateInfo imageInfo =
 	{
 		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,		// VkStructureType          sType;
 		DE_NULL,									// const void*              pNext;
 		(VkImageCreateFlags)0,						// VkImageCreateFlags       flags;
 		VK_IMAGE_TYPE_2D,							// VkImageType              imageType;
 		format,										// VkFormat                 format;
 		makeExtent3D(size.x(), size.y(), 1),		// VkExtent3D               extent;
 		1u,											// uint32_t                 mipLevels;
 		1u,											// uint32_t                 arrayLayers;
 		VK_SAMPLE_COUNT_1_BIT,						// VkSampleCountFlagBits    samples;
 		VK_IMAGE_TILING_OPTIMAL,					// VkImageTiling            tiling;
 		usage,										// VkImageUsageFlags        usage;
 		VK_SHARING_MODE_EXCLUSIVE,					// VkSharingMode            sharingMode;
 		0u,											// uint32_t                 queueFamilyIndexCount;
 		DE_NULL,									// const uint32_t*          pQueueFamilyIndices;
 		VK_IMAGE_LAYOUT_UNDEFINED,					// VkImageLayout            initialLayout;
 	};
 	return imageInfo;
 }

 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");
 }

 } // pipeline
 } // 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 Pipeline specialization constants test utilities
	//--------------------------------------------------------------------*/

	#include "vktPipelineSpecConstantUtil.hpp"
	#include "vkTypeUtil.hpp"
	#include <vector>

	namespace vkt
	{
	namespace pipeline
	{
	using namespace vk;

	GraphicsPipelineBuilder& GraphicsPipelineBuilder::setShader (const DeviceInterface& vk,
	const VkDevice device,
	const VkShaderStageFlagBits stage,
	const ProgramBinary& binary,
	const VkSpecializationInfo* specInfo)
	{
	VkShaderModule module;
	switch (stage)
	{
	case (VK_SHADER_STAGE_VERTEX_BIT):
	DE_ASSERT(m_vertexShaderModule.get() == DE_NULL);
	m_vertexShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
	module = *m_vertexShaderModule;
	break;

	case (VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT):
	DE_ASSERT(m_tessControlShaderModule.get() == DE_NULL);
	m_tessControlShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
	module = *m_tessControlShaderModule;
	break;

	case (VK_SHADER_STAGE_TESSELLATION_EVALUATION_BIT):
	DE_ASSERT(m_tessEvaluationShaderModule.get() == DE_NULL);
	m_tessEvaluationShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
	module = *m_tessEvaluationShaderModule;
	break;

	case (VK_SHADER_STAGE_GEOMETRY_BIT):
	DE_ASSERT(m_geometryShaderModule.get() == DE_NULL);
	m_geometryShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
	module = *m_geometryShaderModule;
	break;

	case (VK_SHADER_STAGE_FRAGMENT_BIT):
	DE_ASSERT(m_fragmentShaderModule.get() == DE_NULL);
	m_fragmentShaderModule = createShaderModule(vk, device, binary, (VkShaderModuleCreateFlags)0);
	module = *m_fragmentShaderModule;
	break;

	default:
	DE_FATAL("Invalid shader stage");
	return *this;
	}

	const VkPipelineShaderStageCreateInfo pipelineShaderStageInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_SHADER_STAGE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineShaderStageCreateFlags)0, // VkPipelineShaderStageCreateFlags flags;
	stage, // VkShaderStageFlagBits stage;
	module, // VkShaderModule module;
	"main", // const char* pName;
	specInfo, // const VkSpecializationInfo* pSpecializationInfo;
	};

	m_shaderStageFlags \|= stage;
	m_shaderStages.push_back(pipelineShaderStageInfo);

	return *this;
	}

	Move<VkPipeline> GraphicsPipelineBuilder::build (const DeviceInterface& vk,
	const VkDevice device,
	const VkPipelineLayout pipelineLayout,
	const VkRenderPass renderPass)
	{
	const VkVertexInputBindingDescription vertexInputBindingDescription =
	{
	0u, // uint32_t binding;
	sizeof(tcu::Vec4), // uint32_t stride; // Vertex is a 4-element vector XYZW, position only
	VK_VERTEX_INPUT_RATE_VERTEX, // VkVertexInputRate inputRate;
	};

	const VkVertexInputAttributeDescription vertexInputAttributeDescription =
	{
	0u, // uint32_t location;
	0u, // uint32_t binding;
	VK_FORMAT_R32G32B32A32_SFLOAT, // VkFormat format;
	0u, // uint32_t offset;
	};

	const VkPipelineVertexInputStateCreateInfo vertexInputStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineVertexInputStateCreateFlags)0, // VkPipelineVertexInputStateCreateFlags flags;
	1u, // uint32_t vertexBindingDescriptionCount;
	&vertexInputBindingDescription, // const VkVertexInputBindingDescription* pVertexBindingDescriptions;
	1u, // uint32_t vertexAttributeDescriptionCount;
	&vertexInputAttributeDescription, // const VkVertexInputAttributeDescription* pVertexAttributeDescriptions;
	};

	const VkPrimitiveTopology topology = (m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT) ? VK_PRIMITIVE_TOPOLOGY_PATCH_LIST : VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST;
	const VkPipelineInputAssemblyStateCreateInfo pipelineInputAssemblyStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_INPUT_ASSEMBLY_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineInputAssemblyStateCreateFlags)0, // VkPipelineInputAssemblyStateCreateFlags flags;
	topology, // VkPrimitiveTopology topology;
	VK_FALSE, // VkBool32 primitiveRestartEnable;
	};

	const VkPipelineTessellationStateCreateInfo pipelineTessellationStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_TESSELLATION_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineTessellationStateCreateFlags)0, // VkPipelineTessellationStateCreateFlags flags;
	3u, // uint32_t patchControlPoints;
	};

	const VkViewport viewport = makeViewport(m_renderSize);
	const VkRect2D scissor = makeRect2D(m_renderSize);

	const VkPipelineViewportStateCreateInfo pipelineViewportStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_VIEWPORT_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineViewportStateCreateFlags)0, // VkPipelineViewportStateCreateFlags flags;
	1u, // uint32_t viewportCount;
	&viewport, // const VkViewport* pViewports;
	1u, // uint32_t scissorCount;
	&scissor, // const VkRect2D* pScissors;
	};

	const VkPipelineRasterizationStateCreateInfo pipelineRasterizationStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_RASTERIZATION_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineRasterizationStateCreateFlags)0, // VkPipelineRasterizationStateCreateFlags flags;
	VK_FALSE, // VkBool32 depthClampEnable;
	VK_FALSE, // VkBool32 rasterizerDiscardEnable;
	VK_POLYGON_MODE_FILL, // VkPolygonMode polygonMode;
	VK_CULL_MODE_NONE, // VkCullModeFlags cullMode;
	VK_FRONT_FACE_COUNTER_CLOCKWISE, // VkFrontFace frontFace;
	VK_FALSE, // VkBool32 depthBiasEnable;
	0.0f, // float depthBiasConstantFactor;
	0.0f, // float depthBiasClamp;
	0.0f, // float depthBiasSlopeFactor;
	1.0f, // float lineWidth;
	};

	const VkPipelineMultisampleStateCreateInfo pipelineMultisampleStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_MULTISAMPLE_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineMultisampleStateCreateFlags)0, // VkPipelineMultisampleStateCreateFlags flags;
	VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits rasterizationSamples;
	VK_FALSE, // VkBool32 sampleShadingEnable;
	0.0f, // float minSampleShading;
	DE_NULL, // const VkSampleMask* pSampleMask;
	VK_FALSE, // VkBool32 alphaToCoverageEnable;
	VK_FALSE // VkBool32 alphaToOneEnable;
	};

	const VkStencilOpState stencilOpStateBasic = makeStencilOpState(
	VK_STENCIL_OP_KEEP, // stencil fail
	VK_STENCIL_OP_KEEP, // depth & stencil pass
	VK_STENCIL_OP_KEEP, // depth only fail
	VK_COMPARE_OP_NEVER, // compare op
	0u, // compare mask
	0u, // write mask
	0u); // reference

	VkPipelineDepthStencilStateCreateInfo pipelineDepthStencilStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineDepthStencilStateCreateFlags)0, // VkPipelineDepthStencilStateCreateFlags flags;
	VK_FALSE, // VkBool32 depthTestEnable;
	VK_FALSE, // VkBool32 depthWriteEnable;
	VK_COMPARE_OP_LESS, // VkCompareOp depthCompareOp;
	VK_FALSE, // VkBool32 depthBoundsTestEnable;
	VK_FALSE, // VkBool32 stencilTestEnable;
	stencilOpStateBasic, // VkStencilOpState front;
	stencilOpStateBasic, // VkStencilOpState back;
	0.0f, // float minDepthBounds;
	1.0f, // float maxDepthBounds;
	};

	const VkColorComponentFlags colorComponentsAll = VK_COLOR_COMPONENT_R_BIT \| VK_COLOR_COMPONENT_G_BIT \| VK_COLOR_COMPONENT_B_BIT \| VK_COLOR_COMPONENT_A_BIT;
	const VkPipelineColorBlendAttachmentState pipelineColorBlendAttachmentState =
	{
	VK_FALSE, // VkBool32 blendEnable;
	VK_BLEND_FACTOR_ONE, // VkBlendFactor srcColorBlendFactor;
	VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstColorBlendFactor;
	VK_BLEND_OP_ADD, // VkBlendOp colorBlendOp;
	VK_BLEND_FACTOR_ONE, // VkBlendFactor srcAlphaBlendFactor;
	VK_BLEND_FACTOR_ZERO, // VkBlendFactor dstAlphaBlendFactor;
	VK_BLEND_OP_ADD, // VkBlendOp alphaBlendOp;
	colorComponentsAll, // VkColorComponentFlags colorWriteMask;
	};

	const VkPipelineColorBlendStateCreateInfo pipelineColorBlendStateInfo =
	{
	VK_STRUCTURE_TYPE_PIPELINE_COLOR_BLEND_STATE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineColorBlendStateCreateFlags)0, // VkPipelineColorBlendStateCreateFlags flags;
	VK_FALSE, // VkBool32 logicOpEnable;
	VK_LOGIC_OP_COPY, // VkLogicOp logicOp;
	1u, // deUint32 attachmentCount;
	&pipelineColorBlendAttachmentState, // const VkPipelineColorBlendAttachmentState* pAttachments;
	{ 0.0f, 0.0f, 0.0f, 0.0f }, // float blendConstants[4];
	};

	const VkGraphicsPipelineCreateInfo graphicsPipelineInfo =
	{
	VK_STRUCTURE_TYPE_GRAPHICS_PIPELINE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkPipelineCreateFlags)0, // VkPipelineCreateFlags flags;
	static_cast<deUint32>(m_shaderStages.size()), // deUint32 stageCount;
	&m_shaderStages[0], // const VkPipelineShaderStageCreateInfo* pStages;
	&vertexInputStateInfo, // const VkPipelineVertexInputStateCreateInfo* pVertexInputState;
	&pipelineInputAssemblyStateInfo, // const VkPipelineInputAssemblyStateCreateInfo* pInputAssemblyState;
	(m_shaderStageFlags & VK_SHADER_STAGE_TESSELLATION_CONTROL_BIT ? &pipelineTessellationStateInfo : DE_NULL), // const VkPipelineTessellationStateCreateInfo* pTessellationState;
	&pipelineViewportStateInfo, // const VkPipelineViewportStateCreateInfo* pViewportState;
	&pipelineRasterizationStateInfo, // const VkPipelineRasterizationStateCreateInfo* pRasterizationState;
	&pipelineMultisampleStateInfo, // const VkPipelineMultisampleStateCreateInfo* pMultisampleState;
	&pipelineDepthStencilStateInfo, // const VkPipelineDepthStencilStateCreateInfo* pDepthStencilState;
	&pipelineColorBlendStateInfo, // const VkPipelineColorBlendStateCreateInfo* pColorBlendState;
	DE_NULL, // const VkPipelineDynamicStateCreateInfo* pDynamicState;
	pipelineLayout, // VkPipelineLayout layout;
	renderPass, // VkRenderPass renderPass;
	0u, // deUint32 subpass;
	DE_NULL, // VkPipeline basePipelineHandle;
	0, // deInt32 basePipelineIndex;
	};

	return createGraphicsPipeline(vk, device, DE_NULL, &graphicsPipelineInfo);
	}

	VkImageCreateInfo makeImageCreateInfo (const tcu::IVec2& size, const VkFormat format, const VkImageUsageFlags usage)
	{
	const VkImageCreateInfo imageInfo =
	{
	VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	(VkImageCreateFlags)0, // VkImageCreateFlags flags;
	VK_IMAGE_TYPE_2D, // VkImageType imageType;
	format, // VkFormat format;
	makeExtent3D(size.x(), size.y(), 1), // VkExtent3D extent;
	1u, // uint32_t mipLevels;
	1u, // uint32_t arrayLayers;
	VK_SAMPLE_COUNT_1_BIT, // VkSampleCountFlagBits samples;
	VK_IMAGE_TILING_OPTIMAL, // VkImageTiling tiling;
	usage, // VkImageUsageFlags usage;
	VK_SHARING_MODE_EXCLUSIVE, // VkSharingMode sharingMode;
	0u, // uint32_t queueFamilyIndexCount;
	DE_NULL, // const uint32_t* pQueueFamilyIndices;
	VK_IMAGE_LAYOUT_UNDEFINED, // VkImageLayout initialLayout;
	};
	return imageInfo;
	}

	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");
	}

	} // pipeline
	} // vkt