/*------------------------------------------------------------------------
 * Vulkan Conformance Tests
 * ------------------------
 *
 * Copyright (c) 2022 Google LLC.
 *
 *
 * 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 Verify Depth/Stencil Write conditions
 *//*--------------------------------------------------------------------*/

#include "deUniquePtr.hpp"

#include "../pipeline/vktPipelineImageUtil.hpp"
#include "vktDrawImageObjectUtil.hpp"

#include "vkImageUtil.hpp"
#include "vkCmdUtil.hpp"
#include "vkObjUtil.hpp"
#include "vkTypeUtil.hpp"
#include "vkImageWithMemory.hpp"
#include "vktTestCaseUtil.hpp"

#include <string>

using namespace vk;

namespace vkt
{
namespace renderpass
{
namespace
{

using tcu::Vec4;
using std::vector;
using de::MovePtr;
using tcu::TextureLevel;

const int	WIDTH	= 64;
const int	HEIGHT	= 64;

enum DiscardType
{
	KILL = 0,
	TERMINATE,
	DEMOTE
};

enum BufferType
{
	DEPTH = 0,
	STENCIL
};

enum MutationMode
{
	WRITE = 0,
	INITIALIZE,
	INITIALIZE_WRITE
};

Move<VkBuffer> makeVertexBuffer (const DeviceInterface& vk, const VkDevice device, const deUint32 queueFamilyIndex)
{
	const VkBufferCreateInfo vertexBufferParams =
	{
		VK_STRUCTURE_TYPE_BUFFER_CREATE_INFO,	// VkStructureType      sType;
		DE_NULL,								// const void*          pNext;
		0u,										// VkBufferCreateFlags  flags;
		1024u,									// VkDeviceSize         size;
		VK_BUFFER_USAGE_VERTEX_BUFFER_BIT,		// VkBufferUsageFlags   usage;
		VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode        sharingMode;
		1u,										// deUint32             queueFamilyIndexCount;
		&queueFamilyIndex						// const deUint32*      pQueueFamilyIndices;
	};

	Move<VkBuffer>			vertexBuffer		= createBuffer(vk, device, &vertexBufferParams);;
	return vertexBuffer;
}

class DepthStencilWriteConditionsInstance : public TestInstance
{
public:
					DepthStencilWriteConditionsInstance	(Context& context, const BufferType& bufferType, const VkFormat& m_bufferFormat);
	tcu::TestStatus	iterate								(void);
private:
	BufferType	m_bufferType;
	VkFormat	m_bufferFormat;
};

DepthStencilWriteConditionsInstance::DepthStencilWriteConditionsInstance (Context& context, const BufferType& bufferType, const VkFormat& bufferFormat)
	: TestInstance	(context), m_bufferType(bufferType), m_bufferFormat(bufferFormat)
{
}

template<typename T>
inline size_t sizeInBytes (const vector<T>& vec)
{
	return vec.size() * sizeof(vec[0]);
}

// A quad covering the whole framebuffer
vector<Vec4> genFullQuadVertices (void)
{
	vector<Vec4> vertices;
	vertices.push_back(Vec4(-1.0f, -1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4( 1.0f, -1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4(-1.0f,  1.0f, 0.0f, 1.0f));
	vertices.push_back(Vec4( 1.0f, -1.0f, 1.0f, 1.0f));
	vertices.push_back(Vec4( 1.0f,  1.0f, 1.0f, 1.0f));
	vertices.push_back(Vec4(-1.0f,  1.0f, 1.0f, 1.0f));

	return vertices;
}

struct Vertex
{
	Vertex(Vec4 vertices_) : vertices(vertices_) {}
	Vec4 vertices;

	static VkVertexInputBindingDescription				getBindingDescription		(void);
	static vector<VkVertexInputAttributeDescription>	getAttributeDescriptions	(void);
};

VkVertexInputBindingDescription Vertex::getBindingDescription (void)
{
	static const VkVertexInputBindingDescription desc =
	{
		0u,										// deUint32             binding;
		static_cast<deUint32>(sizeof(Vertex)),	// deUint32             stride;
		VK_VERTEX_INPUT_RATE_VERTEX,			// VkVertexInputRate    inputRate;
	};

	return desc;
}

vector<VkVertexInputAttributeDescription> Vertex::getAttributeDescriptions (void)
{
	static const vector<VkVertexInputAttributeDescription> desc =
	{
		{
			0u,													// deUint32    location;
			0u,													// deUint32    binding;
			VK_FORMAT_R32G32B32A32_SFLOAT,						// VkFormat    format;
			static_cast<deUint32>(offsetof(Vertex, vertices)),	// deUint32    offset;
		},
	};

	return desc;
}

tcu::TestStatus DepthStencilWriteConditionsInstance::iterate (void)
{
	const DeviceInterface&						vk						= m_context.getDeviceInterface();
	const VkDevice								device					= m_context.getDevice();
	Allocator&									allocator				= m_context.getDefaultAllocator();
	const VkQueue								queue					= m_context.getUniversalQueue();
	const deUint32								queueFamilyIndex		= m_context.getUniversalQueueFamilyIndex();
	const VkDeviceSize							bufferSize				= 16 * 1024;

	const VkExtent2D							renderSize				= {deUint32(WIDTH), deUint32(HEIGHT)};
	const VkRect2D								renderArea				= makeRect2D(makeExtent3D(WIDTH, HEIGHT, 1u));
	const vector<VkRect2D>						scissors				(1u, renderArea);
	const vector<VkViewport>					viewports				(1u, makeViewport(makeExtent3D(WIDTH, HEIGHT, 1u)));

	const vector<Vec4>							vertices				= genFullQuadVertices();
	Move<VkBuffer>								vertexBuffer			= makeVertexBuffer(vk, device, queueFamilyIndex);
	MovePtr<Allocation>							vertexBufferAlloc		= bindBuffer(vk, device, allocator, *vertexBuffer, MemoryRequirement::HostVisible);
	const VkDeviceSize							vertexBufferOffset		= 0ull;

	deMemcpy(vertexBufferAlloc->getHostPtr(), &vertices[0], sizeInBytes(vertices));
	flushAlloc(vk, device, *vertexBufferAlloc);

	const VkImageUsageFlags						colorImageUsage			=   VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;
	const VkImageCreateInfo						colorImageCreateInfo	=
	{
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	//  VkStructureType         sType;
		DE_NULL,								//  const void*             pNext;
		0,										//  VkImageCreateFlags      flags;
		VK_IMAGE_TYPE_2D,						//  VkImageType             imageType;
		VK_FORMAT_R8G8B8A8_UNORM,				//  VkFormat                format;
		makeExtent3D(WIDTH, HEIGHT, 1u),		//  VkExtent3D              extent;
		1u,										//  deUint32                mipLevels;
		1u,										//  deUint32                arrayLayers;
		VK_SAMPLE_COUNT_1_BIT,					//  VkSampleCountFlagBits   samples;
		VK_IMAGE_TILING_OPTIMAL,				//  VkImageTiling           tiling;
		colorImageUsage,						//  VkImageUsageFlags       usage;
		VK_SHARING_MODE_EXCLUSIVE,				//  VkSharingMode           sharingMode;
		0u,										//  deUint32                queueFamilyIndexCount;
		DE_NULL,								//  const deUint32*         pQueueFamilyIndices;
		VK_IMAGE_LAYOUT_UNDEFINED,				//  VkImageLayout           initialLayout;
	};
	const VkImageSubresourceRange				colorSubresourceRange	= makeImageSubresourceRange(VK_IMAGE_ASPECT_COLOR_BIT, 0u, 1, 0, 1);
	const ImageWithMemory						colorImage				(vk, device, m_context.getDefaultAllocator(), colorImageCreateInfo, MemoryRequirement::Any);
	Move<VkImageView>							colorImageView			= makeImageView(vk, device, *colorImage, VK_IMAGE_VIEW_TYPE_2D, VK_FORMAT_R8G8B8A8_UNORM,
																						colorSubresourceRange);

	// Depending on the type of the buffer, create a depth buffer or a stencil buffer.
	const VkImageUsageFlags						depthStencilUsage		= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;

	const VkImageCreateInfo						depthStencilBufferInfo	=
	{
		VK_STRUCTURE_TYPE_IMAGE_CREATE_INFO,	// VkStructureType          sType;
		nullptr,								// const void*              pNext;
		0u,										// VkImageCreateFlags       flags;
		VK_IMAGE_TYPE_2D,						// VkImageType              imageType;
		m_bufferFormat,							// VkFormat                 format;
		makeExtent3D(WIDTH, HEIGHT, 1u),		// VkExtent3D               extent;
		1u,										// deUint32                 mipLevels;
		1u,										// deUint32                 arrayLayers;
		VK_SAMPLE_COUNT_1_BIT,					// VkSampleCountFlagBits    samples;
		VK_IMAGE_TILING_OPTIMAL,				// VkImageTiling            tiling;
		depthStencilUsage,						// VkImageUsageFlags        usage;
		VK_SHARING_MODE_EXCLUSIVE,				// VkSharingMode            sharingMode;
		0u,										// deUint32                 queueFamilyIndexCount;
		nullptr,								// const deUint32*          pQueueFamilyIndices;
		VK_IMAGE_LAYOUT_UNDEFINED,				// VkImageLayout            initialLayout;
	};

	const de::SharedPtr<Draw::Image>			depthStencilImage		= Draw::Image::createAndAlloc(vk, device, depthStencilBufferInfo, m_context.getDefaultAllocator(),
																									  m_context.getUniversalQueueFamilyIndex(), MemoryRequirement::Any);
	const VkImageAspectFlagBits					imageAspectFlagBits		= m_bufferType == BufferType::DEPTH ? VK_IMAGE_ASPECT_DEPTH_BIT : VK_IMAGE_ASPECT_STENCIL_BIT;
	const VkImageSubresourceRange				subresourceRange		= makeImageSubresourceRange(imageAspectFlagBits, 0u, 1u, 0u, 1u);
	Move<VkImageView>							depthStencilImageView	= makeImageView(vk, device, depthStencilImage->object(), VK_IMAGE_VIEW_TYPE_2D, m_bufferFormat, subresourceRange);

	const Move<VkCommandPool>					cmdPool					= createCommandPool(vk, device, VK_COMMAND_POOL_CREATE_RESET_COMMAND_BUFFER_BIT, queueFamilyIndex);
	const Move<VkCommandBuffer>					cmdBuffer				= allocateCommandBuffer(vk, device, *cmdPool, VK_COMMAND_BUFFER_LEVEL_PRIMARY);

	const auto									renderPass				= makeRenderPass(vk, device,VK_FORMAT_R8G8B8A8_UNORM, m_bufferFormat, VK_ATTACHMENT_LOAD_OP_CLEAR,
																						 VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL, VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
	const vector<VkImageView>					attachments				= {colorImageView.get(), depthStencilImageView.get()};
	const auto									framebuffer				= makeFramebuffer(vk, device, renderPass.get(), static_cast<deUint32>(attachments.size()),
																						  de::dataOrNull(attachments), renderSize.width, renderSize.height);

	const Move<VkShaderModule>					vertexModule			= createShaderModule(vk, device, m_context.getBinaryCollection().get("vert"), 0u);
	const Move<VkShaderModule>					fragmentModule			= createShaderModule(vk, device, m_context.getBinaryCollection().get("frag"), 0u);

	const Move<VkPipelineLayout>				pipelineLayout			= makePipelineLayout(vk, device, DE_NULL);

	const VkVertexInputBindingDescription		vtxBindingDescription	= Vertex::getBindingDescription();
	const auto									vtxAttrDescriptions		= Vertex::getAttributeDescriptions();

	const VkPipelineVertexInputStateCreateInfo	vtxInputStateCreateInfo	=
	{
		VK_STRUCTURE_TYPE_PIPELINE_VERTEX_INPUT_STATE_CREATE_INFO,	// VkStructureType                             sType;
		DE_NULL,													// const void*                                 pNext;
		(VkPipelineVertexInputStateCreateFlags)0,					// VkPipelineVertexInputStateCreateFlags       flags;
		1u,															// deUint32                                    vertexBindingDescriptionCount;
		&vtxBindingDescription,										// const VkVertexInputBindingDescription*      pVertexBindingDescriptions
		static_cast<deUint32>(vtxAttrDescriptions.size()),			// deUint32                                    vertexAttributeDescriptionCount
		vtxAttrDescriptions.data(),									// const VkVertexInputAttributeDescription*    pVertexAttributeDescriptions
	};

	// The value in the stencil buffer is replaced if the new value is greater than the previous value.
	const VkStencilOpState						stencilOp				= makeStencilOpState(VK_STENCIL_OP_KEEP, VK_STENCIL_OP_REPLACE, VK_STENCIL_OP_REPLACE,
																							 VK_COMPARE_OP_GREATER, 0xffu, 0xffu, 0u);

	const VkPipelineDepthStencilStateCreateInfo	depthStencilCreateInfo	=
	{
		VK_STRUCTURE_TYPE_PIPELINE_DEPTH_STENCIL_STATE_CREATE_INFO,	// VkStructureType                          sType
		nullptr,													// const void*                              pNext
		0u,															// VkPipelineDepthStencilStateCreateFlags   flags
		m_bufferType == BufferType::DEPTH ? VK_TRUE : VK_FALSE,		// VkBool32                                 depthTestEnable
		VK_TRUE,													// VkBool32                                 depthWriteEnable
		VK_COMPARE_OP_GREATER,										// VkCompareOp                              depthCompareOp
		VK_FALSE,													// VkBool32                                 depthBoundsTestEnable
		m_bufferType == BufferType::STENCIL ? VK_TRUE : VK_FALSE,	// VkBool32                                 stencilTestEnable
		stencilOp,													// VkStencilOpState                         front
		stencilOp,													// VkStencilOpState                         back
		0.0f,														// float                                    minDepthBounds
		1.0f,														// float                                    maxDepthBounds
	};

	const Move<VkPipeline>						graphicsPipeline		= makeGraphicsPipeline(vk, device, pipelineLayout.get(), vertexModule.get(),
																							   DE_NULL, DE_NULL, DE_NULL, fragmentModule.get(), renderPass.get(),
																							   viewports, scissors, VK_PRIMITIVE_TOPOLOGY_TRIANGLE_LIST,
																							   0u, 0u, &vtxInputStateCreateInfo, DE_NULL, DE_NULL,
																							   &depthStencilCreateInfo, DE_NULL, DE_NULL);

	const VkBufferCreateInfo					resultBufferCreateInfo	= makeBufferCreateInfo(bufferSize, VK_BUFFER_USAGE_TRANSFER_DST_BIT);
	Move<VkBuffer>								resultBuffer			= createBuffer(vk, device, &resultBufferCreateInfo);
	MovePtr<Allocation>							resultBufferMemory		= allocator.allocate(getBufferMemoryRequirements(vk, device, *resultBuffer),
																							 MemoryRequirement::HostVisible);

	VK_CHECK(vk.bindBufferMemory(device, *resultBuffer, resultBufferMemory->getMemory(), resultBufferMemory->getOffset()));

	const vector<VkClearValue>					clearColors				=
	{
		makeClearValueColorF32(0.0f, 0.0f, 0.0f, 0.0f),
		makeClearValueDepthStencil(.1f, 0u),
	};

	beginCommandBuffer(vk, *cmdBuffer);

	vk.cmdBindVertexBuffers(*cmdBuffer, 0u, 1u, &vertexBuffer.get(), &vertexBufferOffset);
	vk.cmdBindPipeline(*cmdBuffer, VK_PIPELINE_BIND_POINT_GRAPHICS, *graphicsPipeline);

	beginRenderPass(vk, *cmdBuffer, renderPass.get(), framebuffer.get(), makeRect2D(0, 0, WIDTH, HEIGHT), static_cast<deUint32>(clearColors.size()),
					de::dataOrNull(clearColors), VK_SUBPASS_CONTENTS_INLINE, DE_NULL);
	vk.cmdDraw(*cmdBuffer, static_cast<deUint32>(vertices.size()), 1u, 0u, 0u);
	endRenderPass(vk, *cmdBuffer);

	endCommandBuffer(vk, *cmdBuffer);
	submitCommandsAndWait(vk, device, queue, *cmdBuffer);

	invalidateAlloc(vk, device, *resultBufferMemory);

	de::MovePtr<tcu::TextureLevel>				attachment;

	if (m_bufferType == BufferType::DEPTH)
		attachment = pipeline::readDepthAttachment(vk, device, queue, queueFamilyIndex, allocator, depthStencilImage->object(),
												   m_bufferFormat, tcu::UVec2(WIDTH, HEIGHT), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);
	else
		attachment = pipeline::readStencilAttachment(vk, device, queue, queueFamilyIndex, allocator, depthStencilImage->object(),
													 m_bufferFormat, tcu::UVec2(WIDTH, HEIGHT), VK_IMAGE_LAYOUT_TRANSFER_SRC_OPTIMAL);

	bool										result					= true;
	for (deUint32 y = 0; y < HEIGHT; y++)
	{
		for (deUint32 x = 0; x < WIDTH; x++)
		{
			if (m_bufferType == BufferType::STENCIL)
			{
				const auto stencilPixel = attachment->getAccess().getPixStencil(x, y, 0);
				if (static_cast<deUint32>(stencilPixel) != x % 2)
					result = false;
			}
			else
			{
				const auto depthPixel = attachment->getAccess().getPixDepth(x, y);
				if ((depthPixel < 0.09 || depthPixel > 0.11) && x % 2 == 0)
					result = false;
				if ((depthPixel < 0.19 || depthPixel > 0.21) && x % 2 == 1)
					result = false;
			}
		}
	}

	return result ? tcu::TestStatus::pass("Pass") : tcu::TestStatus::fail("Fail");
}

class DepthStencilWriteConditionsTest : public TestCase
{
public:
						DepthStencilWriteConditionsTest (tcu::TestContext&	testCtx,
														 const std::string&	name,
														 const std::string&	description,
														 const BufferType	bufferType,
														 const DiscardType	discardType,
														 const MutationMode	mutationMode,
														 const VkFormat		bufferFormat);

	virtual void		checkSupport					 (Context&				context) const;
	void				initPrograms					 (SourceCollections&	programCollection) const;
	TestInstance*		createInstance					 (Context&				context) const;
private:
	BufferType		m_bufferType;
	DiscardType		m_discardType;
	MutationMode	m_mutationMode;
	VkFormat		m_bufferFormat;
};

DepthStencilWriteConditionsTest::DepthStencilWriteConditionsTest (tcu::TestContext&		testCtx,
																  const std::string&	name,
																  const std::string&	description,
																  const BufferType		bufferType,
																  const DiscardType		discardType,
																  const MutationMode	mutationMode,
																  const VkFormat		bufferFormat)
	: TestCase	(testCtx, name, description)
	, m_bufferType(bufferType)
	, m_discardType(discardType)
	, m_mutationMode(mutationMode)
	, m_bufferFormat(bufferFormat)
{
}

void DepthStencilWriteConditionsTest::initPrograms (SourceCollections& programCollection) const
{
	/*
	 * The fragment shader has been compiled from the following GLSL shader:
	 *
	 * layout(location = 0) out vec4 outColor;
	 * void main() {
	 *     if (int(gl_FragCoord.x) % 2 == 0)
	 *         discard;
	 *     outColor = vec4(1., 1., 1., 1.);
	 *     gl_FragDepth = 0.2;
	 * }
	 *
	 * If a stencil buffer is enabled, the shader writes to gl_FragStencilRefARB
	 * instead of gl_FragDepth.
	 *
	 * If the mutation mode is INITIALIZE or INITIALIZE_WRITE, the object that
	 * is written to the buffer is allocated with an initial value.
	 *
	 * Demote and terminate commands are used instead of discard if a corresponding
	 * DiscardType has been given.
	 */

	std::ostringstream	vertexSrc;
	vertexSrc
		<< glu::getGLSLVersionDeclaration(glu::GLSL_VERSION_450) << "\n"
		<< "layout(location = 0) in highp vec4 a_position;\n"
		<< "void main (void) {\n"
		<< "    gl_Position = a_position;\n"
		<< "}\n";

	std::string			discardCommand	= "OpKill\n";
	std::string			extensions		= "";
	std::string			capabilities	= "";

	if (m_discardType == DiscardType::TERMINATE)
	{
		extensions = "OpExtension \"SPV_KHR_terminate_invocation\"\n";
		discardCommand = "OpTerminateInvocation\n";
	}
	else if (m_discardType == DiscardType::DEMOTE)
	{
		capabilities = "OpCapability DemoteToHelperInvocationEXT\n";
		extensions = "OpExtension \"SPV_EXT_demote_to_helper_invocation\"\n";
		discardCommand = "OpDemoteToHelperInvocationEXT\n";
	}

	if (m_bufferType == BufferType::STENCIL)
	{
		capabilities += "OpCapability StencilExportEXT\n";
		extensions += "OpExtension \"SPV_EXT_shader_stencil_export\"\n";
	}

	std::ostringstream	fragmentSrc;
	fragmentSrc
		<< "OpCapability Shader\n"
		<< capabilities
		<< extensions
		<< "%1 = OpExtInstImport \"GLSL.std.450\"\n"
		<< "OpMemoryModel Logical GLSL450\n";

	fragmentSrc
		<< "OpEntryPoint Fragment %4 \"main\" %9 %26 %30\n"
		<< "OpExecutionMode %4 OriginUpperLeft\n";

	if (m_bufferType == BufferType::DEPTH)
		fragmentSrc << "OpExecutionMode %4 DepthReplacing\n";

	fragmentSrc
		<< "OpDecorate %9 BuiltIn FragCoord\n"
		<< "OpDecorate %26 Location 0\n";

	if (m_bufferType == BufferType::DEPTH)
		fragmentSrc << "OpDecorate %30 BuiltIn FragDepth\n";
	else
		fragmentSrc << "OpDecorate %30 BuiltIn FragStencilRefEXT\n";

	fragmentSrc
		<< "%2 = OpTypeVoid\n"
		<< "%3 = OpTypeFunction %2\n"
		<< "%6 = OpTypeFloat 32\n"
		<< "%7 = OpTypeVector %6 4\n"
		<< "%8 = OpTypePointer Input %7\n"
		<< "%9 = OpVariable %8 Input\n"
		<< "%10 = OpTypeInt 32 0\n"
		<< "%11 = OpConstant %10 0\n"
		<< "%12 = OpTypePointer Input %6\n"
		<< "%15 = OpTypeInt 32 1\n"
		<< "%17 = OpConstant %15 2\n"
		<< "%19 = OpConstant %15 0\n"
		<< "%20 = OpTypeBool\n"
		<< "%25 = OpTypePointer Output %7\n"
		<< "%26 = OpVariable %25 Output\n"
		<< "%27 = OpConstant %6 1\n"
		<< "%28 = OpConstantComposite %7 %27 %27 %27 %27\n";
	if (m_bufferType == BufferType::DEPTH)
	{
		fragmentSrc << "%29 = OpTypePointer Output %6\n";

		if (m_mutationMode == MutationMode::INITIALIZE || m_mutationMode == MutationMode::INITIALIZE_WRITE)
		{
			// The value the depth buffer is initialized with.
			fragmentSrc << "%const_f32_02 = OpConstant %6 0.2\n";
			fragmentSrc << "%30 = OpVariable %29 Output %const_f32_02\n";
		}
		else
			fragmentSrc << "%30 = OpVariable %29 Output\n";

		// The value written to the depth buffer.
		fragmentSrc << "%31 = OpConstant %6 0.2\n";
	}
	else
	{
		fragmentSrc << "%29 = OpTypePointer Output %15\n";

		if (m_mutationMode == MutationMode::INITIALIZE || m_mutationMode == MutationMode::INITIALIZE_WRITE)
		{
			// The value the stencil buffer is initialized with.
			fragmentSrc << "%const_int_1 = OpConstant %15 1\n";
			fragmentSrc << "%30 = OpVariable %29 Output %const_int_1\n";
		}
		else
			fragmentSrc << "%30 = OpVariable %29 Output\n";

		// The value written to the stencil buffer.
		fragmentSrc << "%31 = OpConstant %15 1\n";
	}

	fragmentSrc
		<< "%4 = OpFunction %2 None %3\n"
		<< "%5 = OpLabel\n"
		<< "%13 = OpAccessChain %12 %9 %11\n"
		<< "%14 = OpLoad %6 %13\n"
		<< "%16 = OpConvertFToS %15 %14\n"
		<< "%18 = OpSMod %15 %16 %17\n"
		<< "%21 = OpIEqual %20 %18 %19\n"
		<< "OpSelectionMerge %23 None\n"
		<< "OpBranchConditional %21 %22 %23\n"
		<< "%22 = OpLabel\n"
		<< discardCommand;
	if (m_discardType == DiscardType::DEMOTE)
		fragmentSrc << "OpBranch %23\n";
	fragmentSrc
		<< "%23 = OpLabel\n"
		<< "OpStore %26 %28\n";

	if (m_mutationMode == MutationMode::WRITE || m_mutationMode == MutationMode::INITIALIZE_WRITE)
		fragmentSrc << "OpStore %30 %31\n";

	fragmentSrc
		<< "OpReturn\n"
		<< "OpFunctionEnd\n";

	programCollection.spirvAsmSources.add("frag") << fragmentSrc.str().c_str();
	programCollection.glslSources.add("vert") << glu::VertexSource(vertexSrc.str());
}

void DepthStencilWriteConditionsTest::checkSupport (Context& context) const
{
	if (m_discardType == DiscardType::DEMOTE)
		context.requireDeviceFunctionality("VK_EXT_shader_demote_to_helper_invocation");
	if (m_discardType == DiscardType::TERMINATE)
		context.requireDeviceFunctionality("VK_KHR_shader_terminate_invocation");
	if (m_bufferType == BufferType::STENCIL)
		context.requireDeviceFunctionality("VK_EXT_shader_stencil_export");

	std::string				formatName				= "VK_FORMAT_D32_SFLOAT_S8_UINT";
	if (m_bufferFormat == VK_FORMAT_D24_UNORM_S8_UINT)
		formatName = "VK_FORMAT_D24_UNORM_S8_UINT";
	if (m_bufferFormat == VK_FORMAT_X8_D24_UNORM_PACK32)
		formatName = "VK_FORMAT_X8_D24_UNORM_PACK32";
	if (m_bufferFormat == VK_FORMAT_D32_SFLOAT)
		formatName = "VK_FORMAT_D32_SFLOAT";

	const auto&				vki						= context.getInstanceInterface();
	const auto				physicalDevice			= context.getPhysicalDevice();
	const VkImageUsageFlags	depthStencilUsage		= VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT;

	VkImageFormatProperties	imageFormatProperties;
	if (vki.getPhysicalDeviceImageFormatProperties(physicalDevice, m_bufferFormat, VK_IMAGE_TYPE_2D,
												   VK_IMAGE_TILING_OPTIMAL, depthStencilUsage, (VkImageCreateFlags)0,
												   &imageFormatProperties) == VK_ERROR_FORMAT_NOT_SUPPORTED)
		TCU_THROW(NotSupportedError, formatName + " not supported.");
}

TestInstance* DepthStencilWriteConditionsTest::createInstance (Context& context) const
{
	return new DepthStencilWriteConditionsInstance(context, m_bufferType, m_bufferFormat);
}

} // anonymous ns

tcu::TestCaseGroup* createDepthStencilWriteConditionsTests (tcu::TestContext& testCtx)
{
	de::MovePtr<tcu::TestCaseGroup> testGroup(new tcu::TestCaseGroup(testCtx, "depth_stencil_write_conditions", "Depth/Stencil Write conditions tests"));

	const VkFormat	depthFormats[4]		= {VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT, VK_FORMAT_X8_D24_UNORM_PACK32, VK_FORMAT_D32_SFLOAT};
	const VkFormat	stencilFormats[2]	= {VK_FORMAT_D32_SFLOAT_S8_UINT, VK_FORMAT_D24_UNORM_S8_UINT};

	for (int i = 0; i < 4; i++)
	{
		VkFormat		format	= depthFormats[i];
		std::string		postfix	= "_d32sf_s8ui";
		if (format == VK_FORMAT_D24_UNORM_S8_UINT)
			postfix = "_d24unorm_s8ui";
		if (format == VK_FORMAT_X8_D24_UNORM_PACK32)
			postfix = "_d24_unorm";
		if (format == VK_FORMAT_D32_SFLOAT)
			postfix = "_d32sf";

		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_kill_write" + postfix, "", BufferType::DEPTH, DiscardType::KILL, MutationMode::WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_kill_initialize" + postfix, "", BufferType::DEPTH, DiscardType::KILL, MutationMode::INITIALIZE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_kill_write_initialize" + postfix, "", BufferType::DEPTH, DiscardType::KILL, MutationMode::INITIALIZE_WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_terminate_write" + postfix, "", BufferType::DEPTH, DiscardType::TERMINATE, MutationMode::WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_terminate_initialize" + postfix, "", BufferType::DEPTH, DiscardType::TERMINATE, MutationMode::INITIALIZE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_terminate_write_initialize" + postfix, "", BufferType::DEPTH, DiscardType::TERMINATE, MutationMode::INITIALIZE_WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_demote_write" + postfix, "", BufferType::DEPTH, DiscardType::DEMOTE, MutationMode::WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_demote_initialize" + postfix, "", BufferType::DEPTH, DiscardType::DEMOTE, MutationMode::INITIALIZE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "depth_demote_write_initialize" + postfix, "", BufferType::DEPTH, DiscardType::DEMOTE, MutationMode::INITIALIZE_WRITE, format));
	}

	for (int i = 0; i < 2; i++)
	{
		VkFormat		format	= stencilFormats[i];
		std::string		postfix	= "_d32sf_s8ui";
		if (format == VK_FORMAT_D24_UNORM_S8_UINT)
			postfix = "_d24unorm_s8ui";

		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_kill_write" + postfix, "", BufferType::STENCIL, DiscardType::KILL, MutationMode::WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_kill_initialize" + postfix, "", BufferType::STENCIL, DiscardType::KILL, MutationMode::INITIALIZE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_kill_write_initialize" + postfix, "", BufferType::STENCIL, DiscardType::KILL, MutationMode::INITIALIZE_WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_terminate_write" + postfix, "", BufferType::STENCIL, DiscardType::TERMINATE, MutationMode::WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_terminate_initialize" + postfix, "", BufferType::STENCIL, DiscardType::TERMINATE, MutationMode::INITIALIZE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_terminate_write_initialize" + postfix, "", BufferType::STENCIL, DiscardType::TERMINATE, MutationMode::INITIALIZE_WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_demote_write" + postfix, "", BufferType::STENCIL, DiscardType::DEMOTE, MutationMode::WRITE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_demote_initialize" + postfix, "", BufferType::STENCIL, DiscardType::DEMOTE, MutationMode::INITIALIZE, format));
		testGroup->addChild(new DepthStencilWriteConditionsTest(testCtx, "stencil_demote_write_initialize" + postfix, "", BufferType::STENCIL, DiscardType::DEMOTE, MutationMode::INITIALIZE_WRITE, format));
	}

	return testGroup.release();
}

} // renderpass
} // vkt