external/vulkancts/modules/vulkan/draw/vktDrawExplicitVertexParameterTests.cpp - third_party/vulkan-cts - Git at Google

 /*------------------------------------------------------------------------
  * Vulkan Conformance Tests
  * ------------------------
  *
  * Copyright (c) 2020 The Khronos Group Inc.
  * Copyright (c) 2020 Valve Corporation
  *
  * 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 VK_AMD_shader_explicit_vertex_parameter tests
  *//*--------------------------------------------------------------------*/

 #include "vktDrawExplicitVertexParameterTests.hpp"

 #include "vktDrawBaseClass.hpp"
 #include "vkQueryUtil.hpp"
 #include "vkCmdUtil.hpp"
 #include "vkTypeUtil.hpp"
 #include "vktTestGroupUtil.hpp"

 #include "vkObjUtil.hpp"
 #include "vkBuilderUtil.hpp"
 #include "vkTypeUtil.hpp"

 #include "deDefs.h"
 #include "deRandom.hpp"
 #include "deString.h"
 #include "deMath.h"

 #include "tcuTestCase.hpp"
 #include "tcuRGBA.hpp"
 #include "tcuTextureUtil.hpp"
 #include "tcuImageCompare.hpp"
 #include "tcuStringTemplate.hpp"

 #include "rrRenderer.hpp"

 #include <string>
 #include <sstream>

 namespace vkt
 {
 namespace Draw
 {
 namespace
 {
 using namespace vk;
 using namespace std;

 enum Interpolation
 {
 	SMOOTH = 0,
 	NOPERSPECTIVE = 1,
 };

 enum AuxiliaryQualifier
 {
 	AUX_NONE = 0,
 	AUX_CENTROID = 1,
 	AUX_SAMPLE = 2,
 };


 enum
 {
 	WIDTH = 16,
 	HEIGHT = 16
 };

 struct PositionValueVertex {
 	PositionValueVertex(tcu::Vec4 pos, float val)
 	: position(pos)
 	, value(val)
 	{}
 public:
 	tcu::Vec4	position;
 	float		value;
 };

 struct DrawParams
 {
 	Interpolation				interpolation;
 	vk::VkSampleCountFlagBits	samples;
 	AuxiliaryQualifier			auxiliaryStorage;
 };

 const char* interpolationToString (Interpolation interpolation)
 {
 	switch (interpolation)
 	{
 		case SMOOTH:
 			return "smooth";
 		case NOPERSPECTIVE:
 			return "noperspective";
 		default:
 			DE_FATAL("Invalid interpolation enum");
 	}

 	return "";
 }

 std::string barycentricVariableString (Interpolation interpolation, AuxiliaryQualifier aux)
 {
 	std::ostringstream name;
 	name << "gl_BaryCoord";
 	switch (interpolation)
 	{
 		case SMOOTH:
 			name << "Smooth";
 			break;
 		case NOPERSPECTIVE:
 			name << "NoPersp";
 			break;
 		default:
 			DE_FATAL("Invalid interpolation enum");
 	}

 	switch (aux)
 	{
 		case AUX_CENTROID:
 			name << "Centroid";
 			break;
 		case AUX_SAMPLE:
 			name << "Sample";
 			break;
 		case AUX_NONE:
 			name << "";
 			break;
 		default:
 			DE_FATAL("Invalid auxiliary storage qualifier enum");
 	}
 	name << "AMD";
 	return name.str();
 }

 const char* auxiliaryQualifierToString (AuxiliaryQualifier aux)
 {
 	switch (aux)
 	{
 		case AUX_CENTROID:
 			return "centroid";
 		case AUX_SAMPLE:
 			return "sample";
 		case AUX_NONE:
 			return "";
 		default:
 			DE_FATAL("Invalid auxiliary storage qualifier enum");
 	}

 	return "";
 }

 std::string getTestName (DrawParams params)
 {
 	std::ostringstream	name;

 	name << interpolationToString(params.interpolation) << "_";

 	if (params.auxiliaryStorage != AUX_NONE)
 		name << auxiliaryQualifierToString(params.auxiliaryStorage) << "_";

 	name << "samples_" << de::toString(params.samples);

 	return name.str();
 }

 class DrawTestInstance : public TestInstance
 {
 public:
 						DrawTestInstance	(Context& context, const DrawParams& data);
 						~DrawTestInstance	(void);
 	tcu::TestStatus		iterate				(void);
 private:
 	DrawParams			m_data;
 };

 DrawTestInstance::DrawTestInstance (Context& context, const DrawParams& data)
 	: vkt::TestInstance		(context)
 	, m_data				(data)
 {
 }

 DrawTestInstance::~DrawTestInstance (void)
 {
 }

 class DrawTestCase : public TestCase
 {
 	public:
 								DrawTestCase		(tcu::TestContext& context, const char* name, const char* desc, const DrawParams data);
 								~DrawTestCase		(void);
 	virtual	void				initPrograms		(SourceCollections& programCollection) const;
 	virtual TestInstance*		createInstance		(Context& context) const;
 	virtual void				checkSupport	(Context& context) const;

 private:
 	DrawParams					m_data;
 };

 DrawTestCase::DrawTestCase (tcu::TestContext& context, const char* name, const char* desc, const DrawParams data)
 	: vkt::TestCase	(context, name, desc)
 	, m_data		(data)
 {
 }

 DrawTestCase::~DrawTestCase	(void)
 {
 }

 void DrawTestCase::checkSupport(Context &context) const
 {
 	context.requireDeviceFunctionality("VK_AMD_shader_explicit_vertex_parameter");

 	if ((context.getDeviceProperties().limits.framebufferColorSampleCounts & m_data.samples) == 0)
 		TCU_THROW(NotSupportedError, "framebufferColorSampleCounts: sample count not supported");
 }

 void DrawTestCase::initPrograms (SourceCollections& programCollection) const
 {
 	const deUint32				numValues	= WIDTH * HEIGHT * m_data.samples;

 	const tcu::StringTemplate	vertShader	(string(
 		"#version 450\n"
 		"#extension GL_AMD_shader_explicit_vertex_parameter : require\n"
 		"\n"
 		"layout(location = 0) in vec4 in_position;\n"
 		"layout(location = 1) in float in_data;\n"
 		"layout(location = 0) __explicitInterpAMD out float out_data_explicit;\n"
 		"layout(location = 1) ${auxqualifier} ${qualifier}        out float out_data_${qualifier};\n"
 		"\n"
 		"out gl_PerVertex {\n"
 		"    vec4  gl_Position;\n"
 		"    float gl_PointSize;\n"
 		"};\n"
 		"\n"
 		"void main() {\n"
 		"    gl_PointSize              = 1.0;\n"
 		"    gl_Position               = in_position;\n"
 		"    out_data_explicit         = in_data;\n"
 		"    out_data_${qualifier}     = in_data;\n"
 		"}\n"));

 	const tcu::StringTemplate	fragShader	(string(
 		"#version 450\n"
 		"#extension GL_AMD_shader_explicit_vertex_parameter : require\n"
 		"\n"
 		"layout(location = 0) __explicitInterpAMD in float in_data_explicit;\n"
 		"layout(location = 1) ${auxqualifier} ${qualifier}        in float in_data_${qualifier};\n"
 		"layout(location = 0) out vec4 out_color;\n"
 		"layout (binding = 0, std140) writeonly buffer Output {\n"
 		"    vec4 values [${numValues}];\n"
 		"} sb_out;\n"
 		"\n"
 		"void main()\n"
 		"{\n"
 		"    uint index = (uint(gl_FragCoord.y) * ${width} * ${samples}) + uint(gl_FragCoord.x) * ${samples} + gl_SampleID;\n"
 		"    // Barycentric coodinates (I, J, K)\n"
 		"    vec3 bary_coord = vec3(${barycoord}.x, ${barycoord}.y, 1.0f - ${barycoord}.x - ${barycoord}.y);\n"
 		"\n"
 		"    // Vertex 0 -> (I = 0, J = 0, K = 1)\n"
 		"    float data0 = interpolateAtVertexAMD(in_data_explicit, 0);\n"
 		"    // Vertex 1 -> (I = 1, J = 0, K = 0)\n"
 		"    float data1 = interpolateAtVertexAMD(in_data_explicit, 1);\n"
 		"    // Vertex 1 -> (I = 0, J = 1, K = 0)\n"
 		"    float data2 = interpolateAtVertexAMD(in_data_explicit, 2);\n"
 		"    // Match data component with barycentric coordinate\n"
 		"    vec3  data  = vec3(data1, data2, data0);\n"
 		"\n"
 		"    float res      = (bary_coord.x * data.x) + (bary_coord.y * data.y) + (bary_coord.z * data.z);\n"
 		"    float expected = in_data_${qualifier};\n"
 		"\n"
 		"    sb_out.values[ index ] = vec4(expected, res, 0u, 0u);\n"
 		"\n"
 		"    const float threshold = 0.0005f;\n"
 		"    if (abs(res - expected) < threshold)\n"
 		"        out_color = vec4(0.0f, 1.0f, 0.0f, 1.0f);\n"
 		"    else\n"
 		"        out_color = vec4(1.0f, 0.0f, 0.0f, 1.0f);\n"
 		"}\n"));

 	map<string, string> attributes;
 	attributes["width"]			= de::toString(WIDTH);
 	attributes["numValues"]		= de::toString(numValues * m_data.samples);
 	attributes["qualifier"]		= interpolationToString(m_data.interpolation);
 	attributes["auxqualifier"]	= auxiliaryQualifierToString(m_data.auxiliaryStorage);
 	attributes["barycoord"]		= barycentricVariableString(m_data.interpolation, m_data.auxiliaryStorage);
 	attributes["samples"]		= de::toString(m_data.samples);

 	programCollection.glslSources.add("vert") << glu::VertexSource(vertShader.specialize(attributes));
 	programCollection.glslSources.add("frag") << glu::FragmentSource(fragShader.specialize(attributes));
 }

 TestInstance* DrawTestCase::createInstance (Context& context) const
 {
 	return new DrawTestInstance(context, m_data);
 }

 tcu::TestStatus DrawTestInstance::iterate (void)
 {
 	de::SharedPtr<Image>			colorTargetImage;
 	de::SharedPtr<Image>			multisampleTargetImage;
 	tcu::TestLog					&log					= m_context.getTestContext().getLog();

 	// Run two iterations with shaders that have different interpolation decorations. Images should still match.
 	const DeviceInterface&			vk						= m_context.getDeviceInterface();
 	const VkDevice					device					= m_context.getDevice();
 	const CmdPoolCreateInfo			cmdPoolCreateInfo		(m_context.getUniversalQueueFamilyIndex());
 	Move<VkCommandPool>				cmdPool					= createCommandPool(vk, device, &cmdPoolCreateInfo);
 	Move<VkCommandBuffer>			cmdBuffer				= allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
 	const Unique<VkShaderModule>	vs						(createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
 	const Unique<VkShaderModule>	fs						(createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
 	de::SharedPtr<Buffer>			vertexBuffer;
 	de::SharedPtr<Buffer>			ssboBuffer;
 	Move<VkRenderPass>				renderPass;
 	Move<VkImageView>				colorTargetView;
 	Move<VkImageView>				multisampleTargetView;
 	Move<VkFramebuffer>				framebuffer;
 	Move<VkPipeline>				pipeline;
 	Move<VkPipelineLayout>			pipelineLayout;
 	Move<VkDescriptorPool>			descriptorPool;
 	Move<VkDescriptorSet>			descriptorSet;
 	Move<VkDescriptorSetLayout>		descriptorSetLayout;

 	vk::VkFormat					imageFormat				= VK_FORMAT_R8G8B8A8_UNORM;
 	const deUint32					numValues				= WIDTH * HEIGHT * m_data.samples;
 	const deBool					useMultisampling		= m_data.samples != VK_SAMPLE_COUNT_1_BIT;

 	// Create color buffer images.
 	{
 		const VkExtent3D			targetImageExtent		= { WIDTH, HEIGHT, 1 };
 		const ImageCreateInfo		targetImageCreateInfo	(VK_IMAGE_TYPE_2D, imageFormat, targetImageExtent, 1, 1, VK_SAMPLE_COUNT_1_BIT,
 															 VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
 		colorTargetImage									= Image::createAndAlloc(vk, device, targetImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());

 		if (useMultisampling)
 		{
 			const ImageCreateInfo		multisampleTargetImageCreateInfo	(VK_IMAGE_TYPE_2D, imageFormat, targetImageExtent, 1, 1, m_data.samples,
 																			 VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT | VK_IMAGE_USAGE_TRANSFER_DST_BIT);
 			multisampleTargetImage											= Image::createAndAlloc(vk, device, multisampleTargetImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
 		}
 	}

 	// Create render pass and frame buffer.
 	{
 		const ImageViewCreateInfo		colorTargetViewInfo		(colorTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, imageFormat);
 		colorTargetView	= createImageView(vk, device, &colorTargetViewInfo);

 		RenderPassCreateInfo			renderPassCreateInfo;
 		renderPassCreateInfo.addAttachment(AttachmentDescription(imageFormat,
 																 VK_SAMPLE_COUNT_1_BIT,
 																 VK_ATTACHMENT_LOAD_OP_LOAD,
 																 VK_ATTACHMENT_STORE_OP_STORE,
 																 VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 																 VK_ATTACHMENT_STORE_OP_STORE,
 																 VK_IMAGE_LAYOUT_UNDEFINED,
 																 VK_IMAGE_LAYOUT_GENERAL));

 		const VkAttachmentReference		colorAttachmentRef			= { 0u, VK_IMAGE_LAYOUT_GENERAL };
 		const VkAttachmentReference		multisampleAttachmentRef	= { 1u, VK_IMAGE_LAYOUT_GENERAL };
 		vector<VkImageView>				colorAttachments;
 		colorAttachments.push_back(*colorTargetView);

 		if (useMultisampling)
 		{
 			const ImageViewCreateInfo		multisamplingTargetViewInfo		(multisampleTargetImage->object(),
 																			 vk::VK_IMAGE_VIEW_TYPE_2D,
 																			 imageFormat);


 			multisampleTargetView = createImageView(vk, device, &multisamplingTargetViewInfo);
 			colorAttachments.push_back(*multisampleTargetView);

 			renderPassCreateInfo.addAttachment(AttachmentDescription(imageFormat,
 																	 m_data.samples,
 																	 vk::VK_ATTACHMENT_LOAD_OP_CLEAR,
 																	 vk::VK_ATTACHMENT_STORE_OP_STORE,
 																	 vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
 																	 vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,
 																	 vk::VK_IMAGE_LAYOUT_UNDEFINED,
 																	 vk::VK_IMAGE_LAYOUT_GENERAL));
 		}

 		renderPassCreateInfo.addSubpass(SubpassDescription(VK_PIPELINE_BIND_POINT_GRAPHICS,
 														   0,
 														   0,
 														   DE_NULL,
 														   1u,
 														   useMultisampling ? &multisampleAttachmentRef : &colorAttachmentRef,
 														   useMultisampling ? &colorAttachmentRef : DE_NULL,
 														   AttachmentReference(),
 														   0,
 														   DE_NULL));

 		renderPass			= createRenderPass(vk, device, &renderPassCreateInfo);

 		const FramebufferCreateInfo		framebufferCreateInfo	(*renderPass, colorAttachments, WIDTH, HEIGHT, 1);
 		framebuffer	= createFramebuffer(vk, device, &framebufferCreateInfo);
 	}

 	// Create vertex buffer.
 	{
 		const PositionValueVertex	vertices[]	=
 		{
 			PositionValueVertex(
 				tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f),		// Coord
 				float(1.0f)),							// Value

 			PositionValueVertex(
 				tcu::Vec4(-1.0f, -1.0f, 0.25f, 0.75f),	// Coord
 				float(0.0f)),							// Value
 			PositionValueVertex(
 				tcu::Vec4( 1.0f,  1.0f, 0.0f, 2.0f),	// Coord
 				float(0.5f)),							// Value
 			PositionValueVertex(
 				tcu::Vec4( 1.0f, -1.0f, 1.0f, 0.5f),	// Coord
 				float(1.0f)),							// Value
 		};

 		const VkDeviceSize			dataSize	= DE_LENGTH_OF_ARRAY(vertices) * sizeof(PositionValueVertex);
 		vertexBuffer							= Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
 		deUint8*					ptr			= reinterpret_cast<deUint8*>(vertexBuffer->getBoundMemory().getHostPtr());

 		deMemcpy(ptr, vertices, static_cast<size_t>(dataSize));
 		flushMappedMemoryRange(vk, device, vertexBuffer->getBoundMemory().getMemory(), vertexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
 	}

 	// Create SSBO buffer
 	{
 		const VkDeviceSize		dataSize	= sizeof(tcu::Vec4) * numValues;
 		ssboBuffer							= Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
 		deUint8*				ptr			= reinterpret_cast<deUint8*>(ssboBuffer->getBoundMemory().getHostPtr());

 		deMemset(ptr, 0, static_cast<size_t>(dataSize));
 		flushMappedMemoryRange(vk, device, ssboBuffer->getBoundMemory().getMemory(), ssboBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
 	}

 	// Create Descriptor Set layout
 	{
 		descriptorSetLayout = DescriptorSetLayoutBuilder()
 			.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT)
 			.build(vk, device);
 	}

 	// Create Descriptor Set
 	{
 		descriptorPool = DescriptorPoolBuilder()
 			.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
 			.build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);

 	    descriptorSet = makeDescriptorSet(vk, device, *descriptorPool, *descriptorSetLayout);

 		const VkDescriptorBufferInfo	bufferInfo =
 		{
 			ssboBuffer->object(),		// VkBuffer		buffer;
 			0u,							// VkDeviceSize	offset;
 			VK_WHOLE_SIZE				// VkDeviceSize	range;
 		};

 		DescriptorSetUpdateBuilder()
 			.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &bufferInfo)
 			.update(vk, device);
 	}

 	// Create pipeline
 	{
 		const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState;

 		VkViewport	viewport	= makeViewport(WIDTH, HEIGHT);
 		VkRect2D	scissor		= makeRect2D(WIDTH, HEIGHT);

 		const VkVertexInputBindingDescription vertexInputBindingDescription = { 0, (deUint32)(sizeof(tcu::Vec4) + sizeof(float)), VK_VERTEX_INPUT_RATE_VERTEX };

 		const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
 		{
 			{ 0u, 0u, vk::VK_FORMAT_R32G32B32A32_SFLOAT, 0u },
 			{ 1u, 0u, vk::VK_FORMAT_R32_SFLOAT, (deUint32)(sizeof(float)* 4) }
 		};

 		PipelineCreateInfo::VertexInputState vertexInputState	= PipelineCreateInfo::VertexInputState(1, &vertexInputBindingDescription, 2, vertexInputAttributeDescriptions);

 		pipelineLayout = makePipelineLayout	(vk, device, *descriptorSetLayout);

 		PipelineCreateInfo pipelineCreateInfo(*pipelineLayout, *renderPass, 0, 0);
 		pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
 		pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
 		pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(vertexInputState));
 		pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP));
 		pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState));
 		pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, vector<VkViewport>(1, viewport), vector<VkRect2D>(1, scissor)));
 		pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
 		pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
 		pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState(m_data.samples));

 		pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
 	}

 	// Queue draw and read results.
 	{
 		const VkQueue				queue				= m_context.getUniversalQueue();
 		const ImageSubresourceRange subresourceRange	(VK_IMAGE_ASPECT_COLOR_BIT);
 		const tcu::Vec4				clearColor			= tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
 		const VkRect2D				renderArea			= makeRect2D(WIDTH, HEIGHT);
 		const VkDeviceSize			vertexBufferOffset	= 0;
 		const VkBuffer				buffer				= vertexBuffer->object();

 		vector<VkClearValue>		clearColors;
 		clearColors.push_back(makeClearValueColor(clearColor));

 		if (useMultisampling)
 			clearColors.push_back(makeClearValueColor(clearColor));

 		beginCommandBuffer(vk, *cmdBuffer, 0u);
 		const VkRenderPassBeginInfo renderPassBeginInfo =
 		{
 			VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO,	// VkStructureType         sType;
 			DE_NULL,									// const void*             pNext;
 			*renderPass,								// VkRenderPass            renderPass;
 			*framebuffer,								// VkFramebuffer           framebuffer;
 			renderArea,									// VkRect2D                renderArea;
 			(deUint32)clearColors.size(),				// deUint32                clearValueCount;
 			clearColors.data(),							// const VkClearValue*     pClearValues;
 		};

 		vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
 		vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &buffer, &vertexBufferOffset);
 		vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipeline);
 		vk.cmdBindDescriptorSets(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
 		vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
 		endRenderPass(vk, *cmdBuffer);
 		endCommandBuffer(vk, *cmdBuffer);

 		submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
 	}

 	qpTestResult res = QP_TEST_RESULT_PASS;

 	{
 		const Allocation& resultAlloc = ssboBuffer->getBoundMemory();
 		invalidateAlloc(vk, device, resultAlloc);

 		const tcu::Vec4*	ptr		= reinterpret_cast<tcu::Vec4*>(resultAlloc.getHostPtr());
 		for (deUint32 valueNdx = 0u; valueNdx < numValues; valueNdx++)
 		{
 			if (deFloatAbs(ptr[valueNdx].x() - ptr[valueNdx].y()) > 0.0005f)
 			{
 				log << tcu::TestLog::Message << "Expected value " << valueNdx << " is " << ptr[valueNdx].x() << ", got " << ptr[valueNdx].y()
 					<< tcu::TestLog::EndMessage;
 				res = QP_TEST_RESULT_FAIL;
 			}
 		}
 	}

 	return tcu::TestStatus(res, qpGetTestResultName(res));
 }

 void createTests (tcu::TestCaseGroup* testGroup)
 {
 	tcu::TestContext&	testCtx		= testGroup->getTestContext();

 	const VkSampleCountFlagBits samples[] =
 	{
 		VK_SAMPLE_COUNT_1_BIT,
 		VK_SAMPLE_COUNT_2_BIT,
 		VK_SAMPLE_COUNT_4_BIT,
 		VK_SAMPLE_COUNT_8_BIT,
 		VK_SAMPLE_COUNT_16_BIT,
 		VK_SAMPLE_COUNT_32_BIT,
 		VK_SAMPLE_COUNT_64_BIT,
 	};

 	const Interpolation interTypes[] =
 	{
 		SMOOTH,
 		NOPERSPECTIVE
 	};

 	const AuxiliaryQualifier auxQualifiers[] =
 	{
 		AUX_NONE,
 		AUX_SAMPLE,
 		AUX_CENTROID,
 	};

 	for (deUint32 sampleNdx	= 0;	sampleNdx	< DE_LENGTH_OF_ARRAY(samples);			sampleNdx++)
 	for (deUint32 auxNdx	= 0;	auxNdx		< DE_LENGTH_OF_ARRAY(auxQualifiers);	auxNdx++)
     for (deUint32 interNdx	= 0;	interNdx	< DE_LENGTH_OF_ARRAY(interTypes);		interNdx++)
 	{
 		if (samples[sampleNdx] == VK_SAMPLE_COUNT_1_BIT && auxQualifiers[auxNdx] != AUX_NONE)
 			continue;

 		const DrawParams params =
 		{
 			interTypes[interNdx],
 			samples[sampleNdx],
 			auxQualifiers[auxNdx],
 		};
 		testGroup->addChild(new DrawTestCase(testCtx, getTestName(params).c_str(), "", params));
 	}
 }

 }	// anonymous

 tcu::TestCaseGroup*	createExplicitVertexParameterTests (tcu::TestContext& testCtx)
 {
 	return createTestGroup(testCtx, "explicit_vertex_parameter", "Tests for VK_AMD_shader_explicit_vertex_parameter.", createTests);
 }

 }	// Draw
 }	// vkt
	/*------------------------------------------------------------------------
	* Vulkan Conformance Tests
	* ------------------------
	*
	* Copyright (c) 2020 The Khronos Group Inc.
	* Copyright (c) 2020 Valve Corporation
	*
	* 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 VK_AMD_shader_explicit_vertex_parameter tests
	//--------------------------------------------------------------------*/

	#include "vktDrawExplicitVertexParameterTests.hpp"

	#include "vktDrawBaseClass.hpp"
	#include "vkQueryUtil.hpp"
	#include "vkCmdUtil.hpp"
	#include "vkTypeUtil.hpp"
	#include "vktTestGroupUtil.hpp"

	#include "vkObjUtil.hpp"
	#include "vkBuilderUtil.hpp"
	#include "vkTypeUtil.hpp"

	#include "deDefs.h"
	#include "deRandom.hpp"
	#include "deString.h"
	#include "deMath.h"

	#include "tcuTestCase.hpp"
	#include "tcuRGBA.hpp"
	#include "tcuTextureUtil.hpp"
	#include "tcuImageCompare.hpp"
	#include "tcuStringTemplate.hpp"

	#include "rrRenderer.hpp"

	#include <string>
	#include <sstream>

	namespace vkt
	{
	namespace Draw
	{
	namespace
	{
	using namespace vk;
	using namespace std;

	enum Interpolation
	{
	SMOOTH = 0,
	NOPERSPECTIVE = 1,
	};

	enum AuxiliaryQualifier
	{
	AUX_NONE = 0,
	AUX_CENTROID = 1,
	AUX_SAMPLE = 2,
	};


	enum
	{
	WIDTH = 16,
	HEIGHT = 16
	};

	struct PositionValueVertex {
	PositionValueVertex(tcu::Vec4 pos, float val)
	: position(pos)
	, value(val)
	{}
	public:
	tcu::Vec4 position;
	float value;
	};

	struct DrawParams
	{
	Interpolation interpolation;
	vk::VkSampleCountFlagBits samples;
	AuxiliaryQualifier auxiliaryStorage;
	};

	const char* interpolationToString (Interpolation interpolation)
	{
	switch (interpolation)
	{
	case SMOOTH:
	return "smooth";
	case NOPERSPECTIVE:
	return "noperspective";
	default:
	DE_FATAL("Invalid interpolation enum");
	}

	return "";
	}

	std::string barycentricVariableString (Interpolation interpolation, AuxiliaryQualifier aux)
	{
	std::ostringstream name;
	name << "gl_BaryCoord";
	switch (interpolation)
	{
	case SMOOTH:
	name << "Smooth";
	break;
	case NOPERSPECTIVE:
	name << "NoPersp";
	break;
	default:
	DE_FATAL("Invalid interpolation enum");
	}

	switch (aux)
	{
	case AUX_CENTROID:
	name << "Centroid";
	break;
	case AUX_SAMPLE:
	name << "Sample";
	break;
	case AUX_NONE:
	name << "";
	break;
	default:
	DE_FATAL("Invalid auxiliary storage qualifier enum");
	}
	name << "AMD";
	return name.str();
	}

	const char* auxiliaryQualifierToString (AuxiliaryQualifier aux)
	{
	switch (aux)
	{
	case AUX_CENTROID:
	return "centroid";
	case AUX_SAMPLE:
	return "sample";
	case AUX_NONE:
	return "";
	default:
	DE_FATAL("Invalid auxiliary storage qualifier enum");
	}

	return "";
	}

	std::string getTestName (DrawParams params)
	{
	std::ostringstream name;

	name << interpolationToString(params.interpolation) << "_";

	if (params.auxiliaryStorage != AUX_NONE)
	name << auxiliaryQualifierToString(params.auxiliaryStorage) << "_";

	name << "samples_" << de::toString(params.samples);

	return name.str();
	}

	class DrawTestInstance : public TestInstance
	{
	public:
	DrawTestInstance (Context& context, const DrawParams& data);
	~DrawTestInstance (void);
	tcu::TestStatus iterate (void);
	private:
	DrawParams m_data;
	};

	DrawTestInstance::DrawTestInstance (Context& context, const DrawParams& data)
	: vkt::TestInstance (context)
	, m_data (data)
	{
	}

	DrawTestInstance::~DrawTestInstance (void)
	{
	}

	class DrawTestCase : public TestCase
	{
	public:
	DrawTestCase (tcu::TestContext& context, const char* name, const char* desc, const DrawParams data);
	~DrawTestCase (void);
	virtual void initPrograms (SourceCollections& programCollection) const;
	virtual TestInstance* createInstance (Context& context) const;
	virtual void checkSupport (Context& context) const;

	private:
	DrawParams m_data;
	};

	DrawTestCase::DrawTestCase (tcu::TestContext& context, const char* name, const char* desc, const DrawParams data)
	: vkt::TestCase (context, name, desc)
	, m_data (data)
	{
	}

	DrawTestCase::~DrawTestCase (void)
	{
	}

	void DrawTestCase::checkSupport(Context &context) const
	{
	context.requireDeviceFunctionality("VK_AMD_shader_explicit_vertex_parameter");

	if ((context.getDeviceProperties().limits.framebufferColorSampleCounts & m_data.samples) == 0)
	TCU_THROW(NotSupportedError, "framebufferColorSampleCounts: sample count not supported");
	}

	void DrawTestCase::initPrograms (SourceCollections& programCollection) const
	{
	const deUint32 numValues = WIDTH * HEIGHT * m_data.samples;

	const tcu::StringTemplate vertShader (string(
	"#version 450\n"
	"#extension GL_AMD_shader_explicit_vertex_parameter : require\n"
	"\n"
	"layout(location = 0) in vec4 in_position;\n"
	"layout(location = 1) in float in_data;\n"
	"layout(location = 0) __explicitInterpAMD out float out_data_explicit;\n"
	"layout(location = 1) ${auxqualifier} ${qualifier} out float out_data_${qualifier};\n"
	"\n"
	"out gl_PerVertex {\n"
	" vec4 gl_Position;\n"
	" float gl_PointSize;\n"
	"};\n"
	"\n"
	"void main() {\n"
	" gl_PointSize = 1.0;\n"
	" gl_Position = in_position;\n"
	" out_data_explicit = in_data;\n"
	" out_data_${qualifier} = in_data;\n"
	"}\n"));

	const tcu::StringTemplate fragShader (string(
	"#version 450\n"
	"#extension GL_AMD_shader_explicit_vertex_parameter : require\n"
	"\n"
	"layout(location = 0) __explicitInterpAMD in float in_data_explicit;\n"
	"layout(location = 1) ${auxqualifier} ${qualifier} in float in_data_${qualifier};\n"
	"layout(location = 0) out vec4 out_color;\n"
	"layout (binding = 0, std140) writeonly buffer Output {\n"
	" vec4 values [${numValues}];\n"
	"} sb_out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" uint index = (uint(gl_FragCoord.y) * ${width} * ${samples}) + uint(gl_FragCoord.x) * ${samples} + gl_SampleID;\n"
	" // Barycentric coodinates (I, J, K)\n"
	" vec3 bary_coord = vec3(${barycoord}.x, ${barycoord}.y, 1.0f - ${barycoord}.x - ${barycoord}.y);\n"
	"\n"
	" // Vertex 0 -> (I = 0, J = 0, K = 1)\n"
	" float data0 = interpolateAtVertexAMD(in_data_explicit, 0);\n"
	" // Vertex 1 -> (I = 1, J = 0, K = 0)\n"
	" float data1 = interpolateAtVertexAMD(in_data_explicit, 1);\n"
	" // Vertex 1 -> (I = 0, J = 1, K = 0)\n"
	" float data2 = interpolateAtVertexAMD(in_data_explicit, 2);\n"
	" // Match data component with barycentric coordinate\n"
	" vec3 data = vec3(data1, data2, data0);\n"
	"\n"
	" float res = (bary_coord.x * data.x) + (bary_coord.y * data.y) + (bary_coord.z * data.z);\n"
	" float expected = in_data_${qualifier};\n"
	"\n"
	" sb_out.values[ index ] = vec4(expected, res, 0u, 0u);\n"
	"\n"
	" const float threshold = 0.0005f;\n"
	" if (abs(res - expected) < threshold)\n"
	" out_color = vec4(0.0f, 1.0f, 0.0f, 1.0f);\n"
	" else\n"
	" out_color = vec4(1.0f, 0.0f, 0.0f, 1.0f);\n"
	"}\n"));

	map<string, string> attributes;
	attributes["width"] = de::toString(WIDTH);
	attributes["numValues"] = de::toString(numValues * m_data.samples);
	attributes["qualifier"] = interpolationToString(m_data.interpolation);
	attributes["auxqualifier"] = auxiliaryQualifierToString(m_data.auxiliaryStorage);
	attributes["barycoord"] = barycentricVariableString(m_data.interpolation, m_data.auxiliaryStorage);
	attributes["samples"] = de::toString(m_data.samples);

	programCollection.glslSources.add("vert") << glu::VertexSource(vertShader.specialize(attributes));
	programCollection.glslSources.add("frag") << glu::FragmentSource(fragShader.specialize(attributes));
	}

	TestInstance* DrawTestCase::createInstance (Context& context) const
	{
	return new DrawTestInstance(context, m_data);
	}

	tcu::TestStatus DrawTestInstance::iterate (void)
	{
	de::SharedPtr<Image> colorTargetImage;
	de::SharedPtr<Image> multisampleTargetImage;
	tcu::TestLog &log = m_context.getTestContext().getLog();

	// Run two iterations with shaders that have different interpolation decorations. Images should still match.
	const DeviceInterface& vk = m_context.getDeviceInterface();
	const VkDevice device = m_context.getDevice();
	const CmdPoolCreateInfo cmdPoolCreateInfo (m_context.getUniversalQueueFamilyIndex());
	Move<VkCommandPool> cmdPool = createCommandPool(vk, device, &cmdPoolCreateInfo);
	Move<VkCommandBuffer> cmdBuffer = allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);
	const Unique<VkShaderModule> vs (createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0));
	const Unique<VkShaderModule> fs (createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0));
	de::SharedPtr<Buffer> vertexBuffer;
	de::SharedPtr<Buffer> ssboBuffer;
	Move<VkRenderPass> renderPass;
	Move<VkImageView> colorTargetView;
	Move<VkImageView> multisampleTargetView;
	Move<VkFramebuffer> framebuffer;
	Move<VkPipeline> pipeline;
	Move<VkPipelineLayout> pipelineLayout;
	Move<VkDescriptorPool> descriptorPool;
	Move<VkDescriptorSet> descriptorSet;
	Move<VkDescriptorSetLayout> descriptorSetLayout;

	vk::VkFormat imageFormat = VK_FORMAT_R8G8B8A8_UNORM;
	const deUint32 numValues = WIDTH * HEIGHT * m_data.samples;
	const deBool useMultisampling = m_data.samples != VK_SAMPLE_COUNT_1_BIT;

	// Create color buffer images.
	{
	const VkExtent3D targetImageExtent = { WIDTH, HEIGHT, 1 };
	const ImageCreateInfo targetImageCreateInfo (VK_IMAGE_TYPE_2D, imageFormat, targetImageExtent, 1, 1, VK_SAMPLE_COUNT_1_BIT,
	VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT \| VK_IMAGE_USAGE_TRANSFER_SRC_BIT \| VK_IMAGE_USAGE_TRANSFER_DST_BIT);
	colorTargetImage = Image::createAndAlloc(vk, device, targetImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());

	if (useMultisampling)
	{
	const ImageCreateInfo multisampleTargetImageCreateInfo (VK_IMAGE_TYPE_2D, imageFormat, targetImageExtent, 1, 1, m_data.samples,
	VK_IMAGE_TILING_OPTIMAL, VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT \| VK_IMAGE_USAGE_TRANSFER_SRC_BIT \| VK_IMAGE_USAGE_TRANSFER_DST_BIT);
	multisampleTargetImage = Image::createAndAlloc(vk, device, multisampleTargetImageCreateInfo, m_context.getDefaultAllocator(), m_context.getUniversalQueueFamilyIndex());
	}
	}

	// Create render pass and frame buffer.
	{
	const ImageViewCreateInfo colorTargetViewInfo (colorTargetImage->object(), VK_IMAGE_VIEW_TYPE_2D, imageFormat);
	colorTargetView = createImageView(vk, device, &colorTargetViewInfo);

	RenderPassCreateInfo renderPassCreateInfo;
	renderPassCreateInfo.addAttachment(AttachmentDescription(imageFormat,
	VK_SAMPLE_COUNT_1_BIT,
	VK_ATTACHMENT_LOAD_OP_LOAD,
	VK_ATTACHMENT_STORE_OP_STORE,
	VK_ATTACHMENT_LOAD_OP_DONT_CARE,
	VK_ATTACHMENT_STORE_OP_STORE,
	VK_IMAGE_LAYOUT_UNDEFINED,
	VK_IMAGE_LAYOUT_GENERAL));

	const VkAttachmentReference colorAttachmentRef = { 0u, VK_IMAGE_LAYOUT_GENERAL };
	const VkAttachmentReference multisampleAttachmentRef = { 1u, VK_IMAGE_LAYOUT_GENERAL };
	vector<VkImageView> colorAttachments;
	colorAttachments.push_back(*colorTargetView);

	if (useMultisampling)
	{
	const ImageViewCreateInfo multisamplingTargetViewInfo (multisampleTargetImage->object(),
	vk::VK_IMAGE_VIEW_TYPE_2D,
	imageFormat);


	multisampleTargetView = createImageView(vk, device, &multisamplingTargetViewInfo);
	colorAttachments.push_back(*multisampleTargetView);

	renderPassCreateInfo.addAttachment(AttachmentDescription(imageFormat,
	m_data.samples,
	vk::VK_ATTACHMENT_LOAD_OP_CLEAR,
	vk::VK_ATTACHMENT_STORE_OP_STORE,
	vk::VK_ATTACHMENT_LOAD_OP_DONT_CARE,
	vk::VK_ATTACHMENT_STORE_OP_DONT_CARE,
	vk::VK_IMAGE_LAYOUT_UNDEFINED,
	vk::VK_IMAGE_LAYOUT_GENERAL));
	}

	renderPassCreateInfo.addSubpass(SubpassDescription(VK_PIPELINE_BIND_POINT_GRAPHICS,
	0,
	0,
	DE_NULL,
	1u,
	useMultisampling ? &multisampleAttachmentRef : &colorAttachmentRef,
	useMultisampling ? &colorAttachmentRef : DE_NULL,
	AttachmentReference(),
	0,
	DE_NULL));

	renderPass = createRenderPass(vk, device, &renderPassCreateInfo);

	const FramebufferCreateInfo framebufferCreateInfo (*renderPass, colorAttachments, WIDTH, HEIGHT, 1);
	framebuffer = createFramebuffer(vk, device, &framebufferCreateInfo);
	}

	// Create vertex buffer.
	{
	const PositionValueVertex vertices[] =
	{
	PositionValueVertex(
	tcu::Vec4(-1.0f, 1.0f, 0.5f, 1.0f), // Coord
	float(1.0f)), // Value

	PositionValueVertex(
	tcu::Vec4(-1.0f, -1.0f, 0.25f, 0.75f), // Coord
	float(0.0f)), // Value
	PositionValueVertex(
	tcu::Vec4( 1.0f, 1.0f, 0.0f, 2.0f), // Coord
	float(0.5f)), // Value
	PositionValueVertex(
	tcu::Vec4( 1.0f, -1.0f, 1.0f, 0.5f), // Coord
	float(1.0f)), // Value
	};

	const VkDeviceSize dataSize = DE_LENGTH_OF_ARRAY(vertices) * sizeof(PositionValueVertex);
	vertexBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize, VK_BUFFER_USAGE_VERTEX_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
	deUint8* ptr = reinterpret_cast<deUint8*>(vertexBuffer->getBoundMemory().getHostPtr());

	deMemcpy(ptr, vertices, static_cast<size_t>(dataSize));
	flushMappedMemoryRange(vk, device, vertexBuffer->getBoundMemory().getMemory(), vertexBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
	}

	// Create SSBO buffer
	{
	const VkDeviceSize dataSize = sizeof(tcu::Vec4) * numValues;
	ssboBuffer = Buffer::createAndAlloc(vk, device, BufferCreateInfo(dataSize, VK_BUFFER_USAGE_STORAGE_BUFFER_BIT), m_context.getDefaultAllocator(), MemoryRequirement::HostVisible);
	deUint8* ptr = reinterpret_cast<deUint8*>(ssboBuffer->getBoundMemory().getHostPtr());

	deMemset(ptr, 0, static_cast<size_t>(dataSize));
	flushMappedMemoryRange(vk, device, ssboBuffer->getBoundMemory().getMemory(), ssboBuffer->getBoundMemory().getOffset(), VK_WHOLE_SIZE);
	}

	// Create Descriptor Set layout
	{
	descriptorSetLayout = DescriptorSetLayoutBuilder()
	.addSingleBinding(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, VK_SHADER_STAGE_FRAGMENT_BIT)
	.build(vk, device);
	}

	// Create Descriptor Set
	{
	descriptorPool = DescriptorPoolBuilder()
	.addType(VK_DESCRIPTOR_TYPE_STORAGE_BUFFER)
	.build(vk, device, VK_DESCRIPTOR_POOL_CREATE_FREE_DESCRIPTOR_SET_BIT, 1u);

	descriptorSet = makeDescriptorSet(vk, device, descriptorPool, descriptorSetLayout);

	const VkDescriptorBufferInfo bufferInfo =
	{
	ssboBuffer->object(), // VkBuffer buffer;
	0u, // VkDeviceSize offset;
	VK_WHOLE_SIZE // VkDeviceSize range;
	};

	DescriptorSetUpdateBuilder()
	.writeSingle(*descriptorSet, DescriptorSetUpdateBuilder::Location::binding(0u), VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, &bufferInfo)
	.update(vk, device);
	}

	// Create pipeline
	{
	const PipelineCreateInfo::ColorBlendState::Attachment vkCbAttachmentState;

	VkViewport viewport = makeViewport(WIDTH, HEIGHT);
	VkRect2D scissor = makeRect2D(WIDTH, HEIGHT);

	const VkVertexInputBindingDescription vertexInputBindingDescription = { 0, (deUint32)(sizeof(tcu::Vec4) + sizeof(float)), VK_VERTEX_INPUT_RATE_VERTEX };

	const VkVertexInputAttributeDescription vertexInputAttributeDescriptions[2] =
	{
	{ 0u, 0u, vk::VK_FORMAT_R32G32B32A32_SFLOAT, 0u },
	{ 1u, 0u, vk::VK_FORMAT_R32_SFLOAT, (deUint32)(sizeof(float)* 4) }
	};

	PipelineCreateInfo::VertexInputState vertexInputState = PipelineCreateInfo::VertexInputState(1, &vertexInputBindingDescription, 2, vertexInputAttributeDescriptions);

	pipelineLayout = makePipelineLayout (vk, device, *descriptorSetLayout);

	PipelineCreateInfo pipelineCreateInfo(pipelineLayout, renderPass, 0, 0);
	pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*vs, "main", VK_SHADER_STAGE_VERTEX_BIT));
	pipelineCreateInfo.addShader(PipelineCreateInfo::PipelineShaderStage(*fs, "main", VK_SHADER_STAGE_FRAGMENT_BIT));
	pipelineCreateInfo.addState(PipelineCreateInfo::VertexInputState(vertexInputState));
	pipelineCreateInfo.addState(PipelineCreateInfo::InputAssemblerState(VK_PRIMITIVE_TOPOLOGY_TRIANGLE_STRIP));
	pipelineCreateInfo.addState(PipelineCreateInfo::ColorBlendState(1, &vkCbAttachmentState));
	pipelineCreateInfo.addState(PipelineCreateInfo::ViewportState(1, vector<VkViewport>(1, viewport), vector<VkRect2D>(1, scissor)));
	pipelineCreateInfo.addState(PipelineCreateInfo::DepthStencilState());
	pipelineCreateInfo.addState(PipelineCreateInfo::RasterizerState());
	pipelineCreateInfo.addState(PipelineCreateInfo::MultiSampleState(m_data.samples));

	pipeline = createGraphicsPipeline(vk, device, DE_NULL, &pipelineCreateInfo);
	}

	// Queue draw and read results.
	{
	const VkQueue queue = m_context.getUniversalQueue();
	const ImageSubresourceRange subresourceRange (VK_IMAGE_ASPECT_COLOR_BIT);
	const tcu::Vec4 clearColor = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
	const VkRect2D renderArea = makeRect2D(WIDTH, HEIGHT);
	const VkDeviceSize vertexBufferOffset = 0;
	const VkBuffer buffer = vertexBuffer->object();

	vector<VkClearValue> clearColors;
	clearColors.push_back(makeClearValueColor(clearColor));

	if (useMultisampling)
	clearColors.push_back(makeClearValueColor(clearColor));

	beginCommandBuffer(vk, *cmdBuffer, 0u);
	const VkRenderPassBeginInfo renderPassBeginInfo =
	{
	VK_STRUCTURE_TYPE_RENDER_PASS_BEGIN_INFO, // VkStructureType sType;
	DE_NULL, // const void* pNext;
	*renderPass, // VkRenderPass renderPass;
	*framebuffer, // VkFramebuffer framebuffer;
	renderArea, // VkRect2D renderArea;
	(deUint32)clearColors.size(), // deUint32 clearValueCount;
	clearColors.data(), // const VkClearValue* pClearValues;
	};

	vk.cmdBeginRenderPass(*cmdBuffer, &renderPassBeginInfo, VK_SUBPASS_CONTENTS_INLINE);
	vk.cmdBindVertexBuffers(*cmdBuffer, 0, 1, &buffer, &vertexBufferOffset);
	vk.cmdBindPipeline(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipeline);
	vk.cmdBindDescriptorSets(cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, pipelineLayout, 0u, 1u, &descriptorSet.get(), 0u, DE_NULL);
	vk.cmdDraw(*cmdBuffer, 4u, 1u, 0u, 0u);
	endRenderPass(vk, *cmdBuffer);
	endCommandBuffer(vk, *cmdBuffer);

	submitCommandsAndWait(vk, device, queue, cmdBuffer.get());
	}

	qpTestResult res = QP_TEST_RESULT_PASS;

	{
	const Allocation& resultAlloc = ssboBuffer->getBoundMemory();
	invalidateAlloc(vk, device, resultAlloc);

	const tcu::Vec4* ptr = reinterpret_cast<tcu::Vec4*>(resultAlloc.getHostPtr());
	for (deUint32 valueNdx = 0u; valueNdx < numValues; valueNdx++)
	{
	if (deFloatAbs(ptr[valueNdx].x() - ptr[valueNdx].y()) > 0.0005f)
	{
	log << tcu::TestLog::Message << "Expected value " << valueNdx << " is " << ptr[valueNdx].x() << ", got " << ptr[valueNdx].y()
	<< tcu::TestLog::EndMessage;
	res = QP_TEST_RESULT_FAIL;
	}
	}
	}

	return tcu::TestStatus(res, qpGetTestResultName(res));
	}

	void createTests (tcu::TestCaseGroup* testGroup)
	{
	tcu::TestContext& testCtx = testGroup->getTestContext();

	const VkSampleCountFlagBits samples[] =
	{
	VK_SAMPLE_COUNT_1_BIT,
	VK_SAMPLE_COUNT_2_BIT,
	VK_SAMPLE_COUNT_4_BIT,
	VK_SAMPLE_COUNT_8_BIT,
	VK_SAMPLE_COUNT_16_BIT,
	VK_SAMPLE_COUNT_32_BIT,
	VK_SAMPLE_COUNT_64_BIT,
	};

	const Interpolation interTypes[] =
	{
	SMOOTH,
	NOPERSPECTIVE
	};

	const AuxiliaryQualifier auxQualifiers[] =
	{
	AUX_NONE,
	AUX_SAMPLE,
	AUX_CENTROID,
	};

	for (deUint32 sampleNdx = 0; sampleNdx < DE_LENGTH_OF_ARRAY(samples); sampleNdx++)
	for (deUint32 auxNdx = 0; auxNdx < DE_LENGTH_OF_ARRAY(auxQualifiers); auxNdx++)
	for (deUint32 interNdx = 0; interNdx < DE_LENGTH_OF_ARRAY(interTypes); interNdx++)
	{
	if (samples[sampleNdx] == VK_SAMPLE_COUNT_1_BIT && auxQualifiers[auxNdx] != AUX_NONE)
	continue;

	const DrawParams params =
	{
	interTypes[interNdx],
	samples[sampleNdx],
	auxQualifiers[auxNdx],
	};
	testGroup->addChild(new DrawTestCase(testCtx, getTestName(params).c_str(), "", params));
	}
	}

	} // anonymous

	tcu::TestCaseGroup* createExplicitVertexParameterTests (tcu::TestContext& testCtx)
	{
	return createTestGroup(testCtx, "explicit_vertex_parameter", "Tests for VK_AMD_shader_explicit_vertex_parameter.", createTests);
	}

	} // Draw
	} // vkt