/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * 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
 */ /*-------------------------------------------------------------------*/

/**
 */ /*!
 * \file  gl4cPostDepthCoverageTests.cpp
 * \brief Conformance tests for the GL_ARB_post_depth_coverage functionality.
 */ /*-------------------------------------------------------------------*/

#include "gl4cPostDepthCoverageTests.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "gluDrawUtil.hpp"
#include "gluShaderProgram.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"

using namespace glw;
using namespace glu;

namespace gl4cts
{
static const char* c_commonVertShader = "#version 450\n"
										"\n"
										"in vec3 vertex;\n"
										"in vec2 inTexCoord;\n"
										"out vec2 texCoord;\n"
										"\n"
										"void main()\n"
										"{\n"
										"    texCoord = inTexCoord;\n"
										"    gl_Position = vec4(vertex, 1);\n"
										"}\n";

/** Constructor.
 *
 *  @param context     Rendering context
 */
PostDepthShaderCase::PostDepthShaderCase(deqp::Context& context)
	: TestCase(context, "PostDepthShader",
			   "Verifies if shader functionality added in ARB_post_depth_coverage extension works as expected")
{
	/* Left blank intentionally */
}

/** Stub deinit method. */
void PostDepthShaderCase::deinit()
{
}

/** Stub init method */
void PostDepthShaderCase::init()
{
	if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_post_depth_coverage"))
		throw tcu::NotSupportedError("GL_ARB_post_depth_coverage not supported");

	m_vertShader = c_commonVertShader;

	m_fragShader1 = "#version 450\n"
					"\n"
					"#extension GL_ARB_post_depth_coverage : require\n"
					"\n"
					"out vec4 fragColor;\n"
					"\n"
					"void main()\n"
					"{\n"
					"    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
					"}\n";

	m_fragShader2 = "#version 450\n"
					"\n"
					"#extension GL_ARB_post_depth_coverage : enable\n"
					"\n"
					"#ifndef GL_ARB_post_depth_coverage\n"
					"  #error GL_ARB_post_depth_coverage not defined\n"
					"#else\n"
					"  #if (GL_ARB_post_depth_coverage != 1)\n"
					"    #error GL_ARB_post_depth_coverage wrong defined\n"
					"  #endif\n"
					"#endif // GL_ARB_post_depth_coverage\n"
					"\n"
					"out vec4 fragColor;\n"
					"\n"
					"void main()\n"
					"{\n"
					"    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
					"}\n";

	m_fragShader3 = "#version 450\n"
					"\n"
					"#extension GL_ARB_post_depth_coverage : enable\n"
					"\n"
					"layout(early_fragment_tests) in;\n"
					"layout(post_depth_coverage) in;\n"
					"\n"
					"out vec4 fragColor;\n"
					"\n"
					"void main()\n"
					"{\n"
					"    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
					"}\n";

	m_fragShader4 = "#version 450\n"
					"\n"
					"#extension GL_ARB_post_depth_coverage : enable\n"
					"\n"
					"layout(post_depth_coverage) in;\n"
					"\n"
					"out vec4 fragColor;\n"
					"\n"
					"void main()\n"
					"{\n"
					"    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
					"}\n";
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 */
tcu::TestNode::IterateResult PostDepthShaderCase::iterate()
{
	const Functions& gl = m_context.getRenderContext().getFunctions();

	ProgramSources sources1 = makeVtxFragSources(m_vertShader, m_fragShader1);
	ShaderProgram  program1(gl, sources1);

	if (!program1.isOk())
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking extension in shader");
		m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program1.getShaderInfo(SHADERTYPE_VERTEX).infoLog
						   << "\n"
						   << "Fragment: " << program1.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
						   << "Program: " << program1.getProgramInfo().infoLog << tcu::TestLog::EndMessage;

		return STOP;
	}

	ProgramSources sources2 = makeVtxFragSources(m_vertShader, m_fragShader2);
	ShaderProgram  program2(gl, sources2);

	if (!program2.isOk())
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking preprocessor directives in shader");
		m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program2.getShaderInfo(SHADERTYPE_VERTEX).infoLog
						   << "\n"
						   << "Fragment: " << program2.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
						   << "Program: " << program2.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
		return STOP;
	}

	ProgramSources sources3 = makeVtxFragSources(m_vertShader, m_fragShader3);
	ShaderProgram  program3(gl, sources3);

	if (!program3.isOk())
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking first layout setup in shader");
		m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program3.getShaderInfo(SHADERTYPE_VERTEX).infoLog
						   << "\n"
						   << "Fragment: " << program3.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
						   << "Program: " << program3.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
		return STOP;
	}

	ProgramSources sources4 = makeVtxFragSources(m_vertShader, m_fragShader4);
	ShaderProgram  program4(gl, sources4);

	if (!program4.isOk())
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking second layout setup in shader");
		m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program4.getShaderInfo(SHADERTYPE_VERTEX).infoLog
						   << "\n"
						   << "Fragment: " << program4.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
						   << "Program: " << program4.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
		return STOP;
	}

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
}

/** Constructor.
 *
 *  @param context     Rendering context
 */
PostDepthSampleMaskCase::PostDepthSampleMaskCase(deqp::Context& context)
	: TestCase(context, "PostDepthSampleMask", "Verifies multisampling with depth test and stencil test functionality "
											   "added in ARB_post_depth_coverage extension")
	, m_framebufferMS(0)
	, m_framebuffer(0)
	, m_textureMS(0)
	, m_texture(0)
	, m_depthStencilRenderbuffer(0)
{
	/* Left blank intentionally */
}

/** Stub deinit method. */
void PostDepthSampleMaskCase::deinit()
{
	const Functions& gl = m_context.getRenderContext().getFunctions();

	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);

	if (m_framebufferMS)
		gl.deleteFramebuffers(1, &m_framebufferMS);
	if (m_framebuffer)
		gl.deleteFramebuffers(1, &m_framebuffer);

	if (m_textureMS)
		gl.deleteTextures(1, &m_textureMS);
	if (m_texture)
		gl.deleteTextures(1, &m_texture);

	if (m_depthStencilRenderbuffer)
		gl.deleteRenderbuffers(1, &m_depthStencilRenderbuffer);
}

/** Stub init method */
void PostDepthSampleMaskCase::init()
{
	if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_post_depth_coverage"))
		throw tcu::NotSupportedError("GL_ARB_post_depth_coverage not supported");

	m_vertShader = c_commonVertShader;

	m_fragShader1a = "#version 450\n"
					 "\n"
					 "#extension GL_ARB_post_depth_coverage : enable\n"
					 "\n"
					 "in vec2 texCoord;\n"
					 "out vec4 fragColor;\n"
					 "\n"
					 "void main()\n"
					 "{\n"
					 "    int samp1 = (gl_SampleMaskIn[0] & 0x1);\n"
					 "    int samp2 = (gl_SampleMaskIn[0] & 0x2) / 2;\n"
					 "    int samp3 = (gl_SampleMaskIn[0] & 0x4) / 4;\n"
					 "    int samp4 = (gl_SampleMaskIn[0] & 0x8) / 8;\n"
					 "    fragColor = vec4(samp1, samp2, samp3, samp4);\n"
					 "}\n";

	m_fragShader1b = "#version 450\n"
					 "\n"
					 "#extension GL_ARB_post_depth_coverage : enable\n"
					 "layout(post_depth_coverage) in;\n"
					 "\n"
					 "in vec2 texCoord;\n"
					 "out vec4 fragColor;\n"
					 "\n"
					 "void main()\n"
					 "{\n"
					 "    int samp1 = (gl_SampleMaskIn[0] & 0x1);\n"
					 "    int samp2 = (gl_SampleMaskIn[0] & 0x2) / 2;\n"
					 "    int samp3 = (gl_SampleMaskIn[0] & 0x4) / 4;\n"
					 "    int samp4 = (gl_SampleMaskIn[0] & 0x8) / 8;\n"
					 "    fragColor = vec4(samp1, samp2, samp3, samp4);\n"
					 "}\n";

	m_fragShader2 = "#version 450\n"
					"\n"
					"in vec2 texCoord;\n"
					"out vec4 fragColor;\n"
					"\n"
					"uniform sampler2DMS texture;\n"
					"\n"
					"void main()\n"
					"{\n"
					"    int samp = int(texCoord.y * 4);\n"
					"    fragColor = texelFetch(texture, ivec2(0, 0), samp);\n"
					"}\n";

	const Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genRenderbuffers(1, &m_depthStencilRenderbuffer);
	gl.bindRenderbuffer(GL_RENDERBUFFER, m_depthStencilRenderbuffer);
	gl.renderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_DEPTH_STENCIL, 1, 1);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorageMultisample");

	gl.genTextures(1, &m_textureMS);
	gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_textureMS);
	gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, 1, 1, GL_TRUE);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample");

	gl.genFramebuffers(1, &m_framebufferMS);
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebufferMS);
	gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, m_textureMS, 0);
	gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilRenderbuffer);
	gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilRenderbuffer);

	gl.genTextures(1, &m_texture);
	gl.bindTexture(GL_TEXTURE_2D, m_texture);
	gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 4);

	gl.genFramebuffers(1, &m_framebuffer);
	gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
	gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0);
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 */
tcu::TestNode::IterateResult PostDepthSampleMaskCase::iterate()
{
	const Functions& gl = m_context.getRenderContext().getFunctions();

	const GLfloat texCoord[] = {
		0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
	};

	const GLfloat verticesNear[] = {
		-1.0f, -1.0f, 0.25f, 0.4f, -1.0f, 0.25f, -1.0f, 0.4f, 0.25f,
	};

	const GLfloat verticesFar[] = {
		-1.0f, -1.0f, 0.75f, 3.0f, -1.0f, 0.75f, -1.0f, 3.0f, 0.75f,
	};

	const GLfloat verticesPost[] = {
		-1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
	};

	const GLuint indicesPre[] = { 0, 1, 2 };

	const GLuint indicesPost[] = { 0, 1, 2, 1, 2, 3 };

	glu::VertexArrayBinding vertexArraysNear[] = { glu::va::Float("vertex", 3, 3, 0, verticesNear),
												   glu::va::Float("inTexCoord", 2, 3, 0, texCoord) };

	glu::VertexArrayBinding vertexArraysFar[] = { glu::va::Float("vertex", 3, 3, 0, verticesFar),
												  glu::va::Float("inTexCoord", 2, 3, 0, texCoord) };

	glu::VertexArrayBinding vertexArraysPost[] = { glu::va::Float("vertex", 3, 4, 0, verticesPost),
												   glu::va::Float("inTexCoord", 2, 4, 0, texCoord) };

	//Prepare shaders
	ProgramSources sources1a = makeVtxFragSources(m_vertShader, m_fragShader1a);
	ShaderProgram  program1a(gl, sources1a);

	if (!program1a.isOk())
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader program fail (non post_depth_coverage).");
		m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program1a.getShaderInfo(SHADERTYPE_VERTEX).infoLog
						   << "\n"
						   << "Fragment: " << program1a.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
						   << "Program: " << program1a.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
		return STOP;
	}

	ProgramSources sources1b = makeVtxFragSources(m_vertShader, m_fragShader1b);
	ShaderProgram  program1b(gl, sources1b);

	if (!program1b.isOk())
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader program fail (post_depth_coverage).");
		m_testCtx.getLog() << tcu::TestLog::Message << "PostDepthCoverage: enabled\n"
						   << "Vertex: " << program1b.getShaderInfo(SHADERTYPE_VERTEX).infoLog << "\n"
						   << "Fragment: " << program1b.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
						   << "Program: " << program1b.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
		return STOP;
	}

	ProgramSources sources2 = makeVtxFragSources(m_vertShader, m_fragShader2);
	ShaderProgram  program2(gl, sources2);

	if (!program2.isOk())
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader program fail (samples reader).");
		m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program2.getShaderInfo(SHADERTYPE_VERTEX).infoLog
						   << "\n"
						   << "Fragment: " << program2.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
						   << "Program: " << program2.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
		return STOP;
	}

	gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
	gl.clearStencil(0);

	//Iterate through all cases
	for (int bufferCase = BUFFERCASE_FIRST; bufferCase <= BUFFERCASE_LAST; ++bufferCase)
		for (int pdcCase = PDCCASE_FIRST; pdcCase <= PDCCASE_LAST; ++pdcCase)
		{
			GLint program = 0;
			if (pdcCase == PDCCASE_DISABLED)
				program = program1a.getProgram();
			else if (pdcCase == PDCCASE_ENABLED)
				program = program1b.getProgram();

			gl.useProgram(program);

			//Firstible use multisampled framebuffer
			gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebufferMS);
			gl.viewport(0, 0, 1, 1);

			gl.enable(GL_MULTISAMPLE);

			//Check which samples should be covered by first draw - calculate expected sample mask
			GLboolean expectedMask[4];

			for (GLint i = 0; i < 4; ++i)
			{
				GLfloat samplePos[2];
				gl.getMultisamplefv(GL_SAMPLE_POSITION, i, &samplePos[0]);
				GLU_EXPECT_NO_ERROR(gl.getError(), "glGetMultisamplefv");
				if (pdcCase == PDCCASE_ENABLED && (samplePos[0] + samplePos[1]) < 0.7f)
					expectedMask[i] = false;
				else
					expectedMask[i] = true;
			}

			if (bufferCase == BUFFERCASE_DEPTH)
				gl.enable(GL_DEPTH_TEST);
			else if (bufferCase == BUFFERCASE_STENCIL)
				gl.enable(GL_STENCIL_TEST);

			gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

			if (bufferCase == BUFFERCASE_STENCIL)
			{
				gl.stencilFunc(GL_ALWAYS, 1, 0xFF);
				gl.stencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
				gl.stencilMask(0xFF);
			}

			//Draw near primitive
			glu::draw(m_context.getRenderContext(), program, DE_LENGTH_OF_ARRAY(vertexArraysNear), vertexArraysNear,
					  glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indicesPre), indicesPre));

			gl.clear(GL_COLOR_BUFFER_BIT);

			if (bufferCase == BUFFERCASE_STENCIL)
			{
				gl.stencilFunc(GL_NOTEQUAL, 1, 0xFF);
				gl.stencilMask(0x00);
			}

			//Draw far primitive
			glu::draw(m_context.getRenderContext(), program, DE_LENGTH_OF_ARRAY(vertexArraysFar), vertexArraysFar,
					  glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indicesPre), indicesPre));

			gl.disable(GL_DEPTH_TEST);
			if (bufferCase == BUFFERCASE_DEPTH)
				gl.disable(GL_DEPTH_TEST);
			else if (bufferCase == BUFFERCASE_STENCIL)
				gl.disable(GL_STENCIL_TEST);

			gl.bindFramebuffer(GL_FRAMEBUFFER, 0);

			gl.useProgram(program2.getProgram());

			gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
			gl.viewport(0, 0, 1, 4);

			//Pass multisampled texture as a uniform
			gl.activeTexture(GL_TEXTURE0);
			gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_textureMS);
			gl.uniform1i(gl.getUniformLocation(program2.getProgram(), "texture"), 0);

			gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);

			//Draw multisampled texture to framebuffer
			glu::draw(m_context.getRenderContext(), program2.getProgram(), DE_LENGTH_OF_ARRAY(vertexArraysPost),
					  vertexArraysPost, glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indicesPost), indicesPost));

			gl.disable(GL_MULTISAMPLE);

			//Read data from framebuffer
			GLubyte pixels[4 * 4];
			deMemset(pixels, 0, 4 * 4);

			gl.readPixels(0, 0, 1, 4, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
			GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels");

			//Verify the result
			GLboolean compiledMask[4];
			deMemset(compiledMask, 0, 4);
			for (int i = 0; i < 4; ++i)
			{
				for (int n			= 0; n < 4; ++n)
					compiledMask[n] = compiledMask[n] || (pixels[4 * i + n] != 0);
			}

			for (int n = 0; n < 4; ++n)
			{
				if (expectedMask[n] != compiledMask[n])
				{
					m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
					m_testCtx.getLog() << tcu::TestLog::Message << "Wrong results for "
									   << (bufferCase == BUFFERCASE_DEPTH ? "BUFFERCASE_DEPTH" :
																			"BUFFERCASE_DEPTH_STENCIL")
									   << " / "
									   << (pdcCase == PDCCASE_DISABLED ? "PDCCASE_DISABLED" : "PDCCASE_ENABLED")
									   << tcu::TestLog::EndMessage;
					return STOP;
				}
			}
		}

	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	return STOP;
}

/** Constructor.
 *
 *  @param context Rendering context.
 */
PostDepthCoverage::PostDepthCoverage(deqp::Context& context)
	: TestCaseGroup(context, "post_depth_coverage_tests",
					"Verify conformance of CTS_ARB_post_depth_coverage implementation")
{
}

/** Initializes the test group contents. */
void PostDepthCoverage::init()
{
	addChild(new PostDepthShaderCase(m_context));
	addChild(new PostDepthSampleMaskCase(m_context));
}

} /* gl4cts namespace */