/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2014-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
 */ /*-------------------------------------------------------------------*/

#include "esextcGeometryShaderOutput.hpp"

#include "gluContextInfo.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"

namespace glcts
{

/* Shared shaders */
const char* const GeometryShaderOutput::m_fragment_shader_code_white_color = "${VERSION}\n"
																			 "\n"
																			 "precision highp float;\n"
																			 "\n"
																			 "out vec4 color;\n"
																			 "\n"
																			 "void main()\n"
																			 "{\n"
																			 "    color = vec4(1, 1, 1, 1);\n"
																			 "}\n";

const char* const GeometryShaderOutput::m_vertex_shader_code_two_vec4 = "${VERSION}\n"
																		"\n"
																		"precision highp float;\n"
																		"\n"
																		"out vec4 v1;\n"
																		"out vec4 v2;\n"
																		"\n"
																		"void main()\n"
																		"{\n"
																		"   v1 = vec4(-0.5, -0.5, 0, 1);\n"
																		"   v2 = vec4( 0.5,  0.5, 0, 1);\n"
																		"}\n";

const char* const GeometryShaderOutput::m_vertex_shader_code_vec4_0_0_0_1 = "${VERSION}\n"
																			"\n"
																			"precision highp float;\n"
																			"\n"
																			"void main()\n"
																			"{\n"
																			"   gl_Position = vec4(0, 0, 0, 1);\n"
																			"}\n";

/* Shaders for GeometryShaderDuplicateOutputLayoutQualifierTest */
const char* const GeometryShaderDuplicateOutputLayoutQualifierTest::m_geometry_shader_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"layout(points)                            in;\n"
	"layout(triangle_strip, max_vertices = 60) out;\n"
	"layout(points)                            out;\n"
	"\n"
	"in vec4 v1[];\n"
	"in vec4 v2[];\n"
	"\n"
	"void main()\n"
	"{\n"
	"    gl_Position = v1[0] + vec4(-0.1, -0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v1[0] + vec4(0.1, -0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v1[0] + vec4(0.1, 0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    EndPrimitive();\n"
	"\n"
	"    gl_Position = v2[0] + vec4(-0.1, -0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v2[0] + vec4(-0.1, 0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v2[0] + vec4(0.1, 0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    EndPrimitive();\n"
	"}\n";

/* Shaders for GeometryShaderDuplicateMaxVerticesLayoutQualifierTest */
const char* const GeometryShaderDuplicateMaxVerticesLayoutQualifierTest::m_geometry_shader_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"layout(points)                            in;\n"
	"layout(triangle_strip, max_vertices = 60) out;\n"
	"layout(max_vertices = 20)                 out;\n"
	"\n"
	"in vec4 v1[];\n"
	"in vec4 v2[];\n"
	"\n"
	"void main()\n"
	"{\n"
	"    gl_Position = v1[0] + vec4(-0.1, -0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v1[0] + vec4(0.1, -0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v1[0] + vec4(0.1, 0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    EndPrimitive();\n"
	"\n"
	"    gl_Position = v2[0] + vec4(-0.1, -0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v2[0] + vec4(-0.1, 0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    gl_Position = v2[0] + vec4(0.1, 0.1, 0, 0);\n"
	"    EmitVertex();\n"
	"    EndPrimitive();\n"
	"}\n";

/* Shaders for GeometryShaderIfVertexEmitIsDoneAtEndTest */
const char* const GeometryShaderIfVertexEmitIsDoneAtEndTest::m_geometry_shader_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout(points)                            in;\n"
	"layout(triangle_strip, max_vertices = 60) out;\n"
	"\n"
	"in vec4 v1[];\n"
	"\n"
	"void main()\n"
	"{\n"
	"    gl_Position = vec4(-1, -1, 0, 1);\n"
	"    EmitVertex();\n"
	"    gl_Position = vec4(-1, 1, 0, 1);\n"
	"    EmitVertex();\n"
	"    gl_Position = vec4(1, 1, 0, 1);\n"
	"    EndPrimitive();\n"
	"}\n";

/* Shaders for GeometryShaderMissingEndPrimitiveCallTest */
const char* const GeometryShaderMissingEndPrimitiveCallTest::m_geometry_shader_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"layout(points)                            in;\n"
	"layout(triangle_strip, max_vertices = 60) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    gl_Position = vec4(-1, -1.004, 0, 1);\n"
	"    EmitVertex();\n"
	"    gl_Position = vec4(-1, 1, 0, 1);\n"
	"    EmitVertex();\n"
	"    gl_Position = vec4(1.004, 1, 0, 1);\n"
	"    EmitVertex();\n"
	"}\n";

/* Shaders for GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest */
const char* const GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest::m_geometry_shader_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"${GEOMETRY_POINT_SIZE_ENABLE}\n"
	"\n"
	"layout(points)                   in;\n"
	"layout(points, max_vertices = 1) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	"    gl_Position  = vec4(-1, -1, 0, 1);\n"
	"    gl_PointSize = 2.0f;\n"
	"    EmitVertex();\n"
	"}\n";

/* Definitions used by all test cases */
#define TEXTURE_HEIGHT (16)
#define TEXTURE_PIXEL_SIZE (4)
#define TEXTURE_WIDTH (16)

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's description
 **/
GeometryShaderOutput::GeometryShaderOutput(Context& context, const ExtParameters& extParams, const char* name,
										   const char* description)
	: TestCaseBase(context, extParams, name, description)
{
	/* Left blank on purpose */
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's desricption
 **/
GeometryShaderDuplicateOutputLayoutQualifierTest::GeometryShaderDuplicateOutputLayoutQualifierTest(
	Context& context, const ExtParameters& extParams, const char* name, const char* description)
	: GeometryShaderOutput(context, extParams, name, description)
{
	/* Nothing to be done here */
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *  Note the function throws exception should an error occur!
 **/
tcu::TestCase::IterateResult GeometryShaderDuplicateOutputLayoutQualifierTest::iterate()
{
	if (!m_is_geometry_shader_extension_supported)
	{
		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* Verify the program does not build. */
	bool result = doesProgramBuild(1, &m_fragment_shader_code_white_color, 1, &m_geometry_shader_code, 1,
								   &m_vertex_shader_code_two_vec4);

	if (false == result)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "Invalid program was linked successfully."
						   << tcu::TestLog::EndMessage;

		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}

	return STOP;
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's desricption
 **/
GeometryShaderDuplicateMaxVerticesLayoutQualifierTest::GeometryShaderDuplicateMaxVerticesLayoutQualifierTest(
	Context& context, const ExtParameters& extParams, const char* name, const char* description)
	: GeometryShaderOutput(context, extParams, name, description)
{
	/* Nothing to be done here */
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *  Note the function throws exception should an error occur!
 **/
tcu::TestCase::IterateResult GeometryShaderDuplicateMaxVerticesLayoutQualifierTest::iterate()
{
	if (!m_is_geometry_shader_extension_supported)
	{
		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* Verify the program does not build. */
	bool result = doesProgramBuild(1, &m_fragment_shader_code_white_color, 1, &m_geometry_shader_code, 1,
								   &m_vertex_shader_code_two_vec4);

	if (false == result)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "Invalid program was linked successfully."
						   << tcu::TestLog::EndMessage;

		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}

	return STOP;
}

/** Constructor
 *
 *  @param context                  Test context
 *  @param name                     Test case's name
 *  @param description              Test case's desricption
 *  @param geometry_shader_code     Code of geometry shader
 **/
GeometryShaderOutputRenderingBase::GeometryShaderOutputRenderingBase(Context& context, const ExtParameters& extParams,
																	 const char* name, const char* description,
																	 const char* geometry_shader_code)
	: GeometryShaderOutput(context, extParams, name, description)
	, m_geometry_shader_code(geometry_shader_code)
	, m_program_object_id(0)
	, m_vertex_shader_id(0)
	, m_fragment_shader_id(0)
	, m_geometry_shader_id(0)
	, m_vao_id(0)
	, m_fbo_id(0)
	, m_color_tex_id(0)
{
	/* Left blank on purpose */
}

/** Initialize test case
 *
 **/
void GeometryShaderOutputRenderingBase::initTest()
{
	if (!m_is_geometry_shader_extension_supported)
	{
		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* GL functions */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Create shader objects */
	m_fragment_shader_id = gl.createShader(GL_FRAGMENT_SHADER);
	m_geometry_shader_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_vertex_shader_id   = gl.createShader(GL_VERTEX_SHADER);

	/* Create program object */
	m_program_object_id = gl.createProgram();

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create program object");

	/* Build the program object */
	if (false == buildProgram(m_program_object_id, m_fragment_shader_id, 1, &m_fragment_shader_code_white_color,
							  m_geometry_shader_id, 1, &m_geometry_shader_code, m_vertex_shader_id, 1,
							  &m_vertex_shader_code_vec4_0_0_0_1))
	{
		TCU_FAIL("Could not create program from valid vertex/geometry/fragment shader");
	}

	/* Set up texture object and a FBO */
	gl.genTextures(1, &m_color_tex_id);
	gl.genFramebuffers(1, &m_fbo_id);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create framebuffer");

	if (false ==
		setupFramebufferWithTextureAsAttachment(m_fbo_id, m_color_tex_id, GL_RGBA8, TEXTURE_WIDTH, TEXTURE_HEIGHT))
	{
		TCU_FAIL("Failed to setup framebuffer");
	}

	/* Set up a vertex array object */
	gl.genVertexArrays(1, &m_vao_id);
	gl.bindVertexArray(m_vao_id);

	if (!glu::isContextTypeES(m_context.getRenderContext().getType()))
	{
		gl.enable(GL_PROGRAM_POINT_SIZE);
	}

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not create vertex array object");
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *  Note the function throws exception should an error occur!
 **/
tcu::TestCase::IterateResult GeometryShaderOutputRenderingBase::iterate()
{
	initTest();

	/* Variables used for image verification purposes */
	unsigned char result_image[TEXTURE_HEIGHT * TEXTURE_WIDTH * TEXTURE_PIXEL_SIZE];

	/* GL functions */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Render */
	gl.useProgram(m_program_object_id);

	gl.clearColor(0 /* red */, 0 /* green */, 0 /* blue */, 0 /* alpha */);
	gl.clear(GL_COLOR_BUFFER_BIT);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not clear the color buffer");

	gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Call drawArrays() failed");

	/* Extract image from FBO */
	gl.readPixels(0 /* x */, 0 /* y */, TEXTURE_WIDTH, TEXTURE_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, result_image);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Could not read back pixels from color buffer");

	/* Run verification */
	if (true == verifyResult(result_image, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_PIXEL_SIZE))
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}

	return STOP;
}

/** Deinitialize test case
 *
 **/
void GeometryShaderOutputRenderingBase::deinit()
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Reset OpenGL ES state */
	gl.useProgram(0);
	gl.bindVertexArray(0);
	gl.bindTexture(GL_TEXTURE_2D, 0);
	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
	if (!glu::isContextTypeES(m_context.getRenderContext().getType()))
	{
		gl.disable(GL_PROGRAM_POINT_SIZE);
	}

	if (m_program_object_id != 0)
	{
		gl.deleteProgram(m_program_object_id);
	}

	if (m_fragment_shader_id != 0)
	{
		gl.deleteShader(m_fragment_shader_id);
	}

	if (m_geometry_shader_id != 0)
	{
		gl.deleteShader(m_geometry_shader_id);
	}

	if (m_vertex_shader_id != 0)
	{
		gl.deleteShader(m_vertex_shader_id);
	}

	if (m_vao_id != 0)
	{
		gl.deleteVertexArrays(1, &m_vao_id);
	}

	if (m_color_tex_id != 0)
	{
		gl.deleteTextures(1, &m_color_tex_id);
	}

	if (m_fbo_id != 0)
	{
		gl.deleteFramebuffers(1, &m_fbo_id);
	}

	/* Release base class */
	TestCaseBase::deinit();
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's desricption
 **/
GeometryShaderIfVertexEmitIsDoneAtEndTest::GeometryShaderIfVertexEmitIsDoneAtEndTest(Context&			  context,
																					 const ExtParameters& extParams,
																					 const char*		  name,
																					 const char*		  description)
	: GeometryShaderOutputRenderingBase(context, extParams, name, description, m_geometry_shader_code)
{
	/* Left blank on purpose */
}

/** Verifies result of draw call
 *
 *  @param result_image Image data
 *  @param width        Image width
 *  @param height       Image height
 *  @param pixel_size   Size of single pixel in bytes
 *
 *  @return true  if test succeded
 *          false if the test failed
 *          Note the function throws exception should an error occur!
 **/
bool GeometryShaderIfVertexEmitIsDoneAtEndTest::verifyResult(const unsigned char* result_image, unsigned int width,
															 unsigned int height, unsigned int pixel_size) const
{
	/* Check if the data was modified during the rendering process */
	for (unsigned int y = 0; y < height; ++y)
	{
		for (unsigned int x = 0; x < width; ++x)
		{
			if (false == comparePixel(result_image, x, y, width, height, pixel_size))
			{
				m_testCtx.getLog() << tcu::TestLog::Message
								   << "Vertex emitted without a corresponding EmitVertex() call made"
								   << tcu::TestLog::EndMessage;

				return false;
			}
		}
	}

	/* Done */
	return true;
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's desricption
 **/
GeometryShaderMissingEndPrimitiveCallTest::GeometryShaderMissingEndPrimitiveCallTest(Context&			  context,
																					 const ExtParameters& extParams,
																					 const char*		  name,
																					 const char*		  description)
	: GeometryShaderOutputRenderingBase(context, extParams, name, description, m_geometry_shader_code)
{
	/* Left blank on purpose */
}

/** Verifies result of draw call
 *
 *  @param result_image Image data
 *  @param width        Image width
 *  @param height       Image height
 *  @param pixel_size   Size of single pixel in bytes
 *
 *  @return true  if test succeded
 *          false if the test failed
 **/
bool GeometryShaderMissingEndPrimitiveCallTest::verifyResult(const unsigned char* result_image, unsigned int width,
															 unsigned int height, unsigned int pixel_size) const
{
	/* Image size */
	const unsigned int left   = 0;
	const unsigned int right  = width - 1;
	const unsigned int bottom = 0;
	const unsigned int top	= height - 1;

	/* Verification */
	if ((true == comparePixel(result_image, left, bottom, width, height, pixel_size, 255, 255, 255, 255)) &&
		(true == comparePixel(result_image, left, top, width, height, pixel_size, 255, 255, 255, 255)) &&
		(true == comparePixel(result_image, right, top, width, height, pixel_size, 255, 255, 255, 255)) &&
		(true == comparePixel(result_image, right, bottom, width, height, pixel_size, 0, 0, 0, 0)))
	{
		return true;
	}
	else
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "EndPrimitive() is not called at the end of geometry shader"
						   << tcu::TestLog::EndMessage;

		return false;
	}
}

/** Constructor
 *
 *  @param context       Test context
 *  @param name          Test case's name
 *  @param description   Test case's desricption
 **/
GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest::
	GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest(Context& context, const ExtParameters& extParams,
																const char* name, const char* description)
	: GeometryShaderOutputRenderingBase(context, extParams, name, description, m_geometry_shader_code)
{
	/* Left blank on purpose */
}

/** Executes the test.
 *  Sets the test result to QP_TEST_RESULT_FAIL if the test failed, QP_TEST_RESULT_PASS otherwise.
 *  @return STOP if the test has finished, CONTINUE to indicate iterate should be called once again.
 *  Note the function throws exception should an error occur!
 **/
tcu::TestCase::IterateResult GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest::iterate()
{
	if (!m_is_geometry_shader_point_size_supported)
	{
		throw tcu::NotSupportedError(GEOMETRY_SHADER_POINT_SIZE_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	return GeometryShaderOutputRenderingBase::iterate();
}

/** Verifies result of draw call
 *
 *  @param result_image Image data
 *  @param width        Image width
 *  @param height       Image height
 *  @param pixel_size   Size of single pixel in bytes
 *
 *  @return true  if test succeded
 *          false if the test failed
 *          Note the function throws exception should an error occur!
 **/
bool GeometryShaderMissingEndPrimitiveCallForSinglePrimitiveTest::verifyResult(const unsigned char* result_image,
																			   unsigned int width, unsigned int height,
																			   unsigned int pixel_size) const
{
	/* Image size */
	const unsigned int left   = 0;
	const unsigned int right  = width - 1;
	const unsigned int bottom = 0;
	const unsigned int top	= height - 1;

	/* Verification */
	if ((true == comparePixel(result_image, left, bottom, width, height, pixel_size, 255, 255, 255, 255)) &&
		(true == comparePixel(result_image, left, top, width, height, pixel_size, 0, 0, 0, 0)) &&
		(true == comparePixel(result_image, right, top, width, height, pixel_size, 0, 0, 0, 0)) &&
		(true == comparePixel(result_image, right, bottom, width, height, pixel_size, 0, 0, 0, 0)))
	{
		return true;
	}
	else
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "EndPrimitive() is not done for a single primitive"
						   << tcu::TestLog::EndMessage;

		return false;
	}
}

} // namespace glcts