external/openglcts/modules/gl/gl3cGLSLnoperspectiveTests.cpp

/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2015-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  gl3cGLSLnoperspectiveTests.cpp
 * \brief Implements conformance tests for "GLSL no perspective" functionality.
 */ /*-------------------------------------------------------------------*/

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

namespace gl3cts
{
/** Compiles shader
 *
 * @param context     Context of test framework
 * @param shader_id   Shader id
 * @param shader_code Shader source code
 **/
void compile_shader(deqp::Context& context, glw::GLuint shader_id, const glw::GLchar* shader_code)
{
	/* GL entry points */
	const glw::Functions& gl = context.getRenderContext().getFunctions();

	/* Compilation status */
	glw::GLint status = GL_FALSE;

	/* Set source code */
	gl.shaderSource(shader_id, 1 /* count */, &shader_code, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "ShaderSource");

	/* Compile */
	gl.compileShader(shader_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "CompileShader");

	/* Get compilation status */
	gl.getShaderiv(shader_id, GL_COMPILE_STATUS, &status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv");

	/* Log compilation error */
	if (GL_TRUE != status)
	{
		glw::GLint				 length = 0;
		std::vector<glw::GLchar> message;

		/* Error log length */
		gl.getShaderiv(shader_id, GL_INFO_LOG_LENGTH, &length);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderiv");

		/* Prepare storage */
		message.resize(length);

		/* Get error log */
		gl.getShaderInfoLog(shader_id, length, 0, &message[0]);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetShaderInfoLog");

		/* Log */
		context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to compile shader:\n"
										  << &message[0] << tcu::TestLog::EndMessage
										  << tcu::TestLog::KernelSource(shader_code);

		TCU_FAIL("Failed to compile shader");
	}
}

/** Creates and compiles shader
 *
 * @param context Context of test framework
 * @param stage   Shader stage
 * @param code    Shader source code
 *
 * @return Id of created shader
 **/
glw::GLuint prepare_shader(deqp::Context& context, glw::GLenum stage, const glw::GLchar* code)
{
	/* GL entry points */
	const glw::Functions& gl = context.getRenderContext().getFunctions();

	/* Compilation status */
	glw::GLuint id = 0;

	/* Create */
	id = gl.createShader(stage);
	GLU_EXPECT_NO_ERROR(gl.getError(), "CreateShader");

	try
	{
		compile_shader(context, id, code);
	}
	catch (const std::exception& exc)
	{
		gl.deleteShader(id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "DeleteShader");

		TCU_FAIL(exc.what());
	}

	return id;
}

/** Attach shaders and link program
 *
 * @param context            Context of test framework
 * @param fragment_shader_id Id of fragment shader
 * @param vertex_shader_id   Id of vertex shader
 * @param program_object_id  Id of program object
 **/
void link_program(deqp::Context& context, glw::GLuint fragment_shader_id, glw::GLuint vertex_shader_id,
				  glw::GLuint program_object_id)
{
	/* GL entry points */
	const glw::Functions& gl = context.getRenderContext().getFunctions();

	/* Link status */
	glw::GLint status = GL_FALSE;

	/* Attach shaders */
	if (0 != fragment_shader_id)
	{
		gl.attachShader(program_object_id, fragment_shader_id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
	}

	if (0 != vertex_shader_id)
	{
		gl.attachShader(program_object_id, vertex_shader_id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "AttachShader");
	}

	/* Link */
	gl.linkProgram(program_object_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "LinkProgram");

	/* Get link status */
	gl.getProgramiv(program_object_id, GL_LINK_STATUS, &status);
	GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");

	/* Log link error */
	if (GL_TRUE != status)
	{
		glw::GLint				 length = 0;
		std::vector<glw::GLchar> message;

		/* Get error log length */
		gl.getProgramiv(program_object_id, GL_INFO_LOG_LENGTH, &length);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramiv");

		message.resize(length);

		/* Get error log */
		gl.getProgramInfoLog(program_object_id, length, 0, &message[0]);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GetProgramInfoLog");

		/* Log */
		context.getTestContext().getLog() << tcu::TestLog::Message << "Failed to link program:\n"
										  << &message[0] << tcu::TestLog::EndMessage;

		TCU_FAIL("Failed to link program");
	}
}

/** Create and build program
 *
 * @param context              Context of test framework
 * @param fragment_shader_code Fragment shader source code
 * @param vertex_shader_code   Vertex shader source code
 *
 * @return Id of program object
 **/
glw::GLuint prepare_program(deqp::Context& context, const glw::GLchar* fragment_shader_code,
							const glw::GLchar* vertex_shader_code)
{
	/* GL entry points */
	const glw::Functions& gl = context.getRenderContext().getFunctions();

	glw::GLuint fragment_shader_id = 0;
	glw::GLuint program_object_id  = 0;
	glw::GLuint vertex_shader_id   = 0;

	try
	{
		/* Create shader objects and compile */
		if (0 != fragment_shader_code)
		{
			fragment_shader_id = prepare_shader(context, GL_FRAGMENT_SHADER, fragment_shader_code);
		}

		if (0 != vertex_shader_code)
		{
			vertex_shader_id = prepare_shader(context, GL_VERTEX_SHADER, vertex_shader_code);
		}

		/* Create program object */
		program_object_id = gl.createProgram();
		GLU_EXPECT_NO_ERROR(gl.getError(), "CreateProgram");

		/* Link program */
		link_program(context, fragment_shader_id, vertex_shader_id, program_object_id);
	}
	catch (const std::exception& exc)
	{
		if (0 != program_object_id)
			gl.deleteProgram(program_object_id);
		if (0 != fragment_shader_id)
			gl.deleteShader(fragment_shader_id);
		if (0 != vertex_shader_id)
			gl.deleteShader(vertex_shader_id);

		TCU_FAIL(exc.what());
	}

	/* Shader ids can now be deleted */
	if (0 != fragment_shader_id)
		gl.deleteShader(fragment_shader_id);
	if (0 != vertex_shader_id)
		gl.deleteShader(vertex_shader_id);

	/* Done */
	return program_object_id;
}

/** Constructor.
 *
 *  @param context Rendering context.
 *
 **/
FunctionalTest::FunctionalTest(deqp::Context& context)
	: TestCase(context, "functionaltest", "Verifies that interpolation qualifier has imact on results of rendering")
{
	/* Left blank intentionally */
}

/** Executes test iteration.
 *
 *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 */
tcu::TestNode::IterateResult FunctionalTest::iterate()
{
	static const char* vs_default = "#version 130\n"
									"\n"
									"in vec4 in_position;\n"
									"in vec4 in_color;\n"
									"\n"
									"out vec4 vs_fs_color;\n"
									"\n"
									"void main()\n"
									"{\n"
									"    gl_Position = in_position;\n"
									"    vs_fs_color = in_color;\n"
									"}\n"
									"\n";

	static const char* vs_flat = "#version 130\n"
								 "\n"
								 "in vec4 in_position;\n"
								 "in vec4 in_color;\n"
								 "\n"
								 "flat out vec4 vs_fs_color;\n"
								 "\n"
								 "void main()\n"
								 "{\n"
								 "    gl_Position = in_position;\n"
								 "    vs_fs_color = in_color;\n"
								 "}\n"
								 "\n";

	static const char* vs_noperspective = "#version 130\n"
										  "\n"
										  "in vec4 in_position;\n"
										  "in vec4 in_color;\n"
										  "\n"
										  "noperspective out vec4 vs_fs_color;\n"
										  "\n"
										  "void main()\n"
										  "{\n"
										  "    gl_Position = in_position;\n"
										  "    vs_fs_color = in_color;\n"
										  "}\n"
										  "\n";

	static const char* vs_smooth = "#version 130\n"
								   "\n"
								   "in vec4 in_position;\n"
								   "in vec4 in_color;\n"
								   "\n"
								   "smooth out vec4 vs_fs_color;\n"
								   "\n"
								   "void main()\n"
								   "{\n"
								   "    gl_Position = in_position;\n"
								   "    vs_fs_color = in_color;\n"
								   "}\n"
								   "\n";

	static const char* fs_default = "#version 130\n"
									"\n"
									"in vec4 vs_fs_color;\n"
									"\n"
									"out vec4 out_color;\n"
									"\n"
									"void main()\n"
									"{\n"
									"    out_color = vs_fs_color;\n"
									"}\n"
									"\n";

	static const char* fs_flat = "#version 130\n"
								 "\n"
								 "flat in vec4 vs_fs_color;\n"
								 "\n"
								 "out vec4 out_color;\n"
								 "\n"
								 "void main()\n"
								 "{\n"
								 "    out_color = vs_fs_color;\n"
								 "}\n"
								 "\n";

	static const char* fs_noperspective = "#version 130\n"
										  "\n"
										  "noperspective in vec4 vs_fs_color;\n"
										  "\n"
										  "out vec4 out_color;\n"
										  "\n"
										  "void main()\n"
										  "{\n"
										  "    out_color = vs_fs_color;\n"
										  "}\n"
										  "\n";

	static const char* fs_smooth = "#version 130\n"
								   "\n"
								   "smooth in vec4 vs_fs_color;\n"
								   "\n"
								   "out vec4 out_color;\n"
								   "\n"
								   "void main()\n"
								   "{\n"
								   "    out_color = vs_fs_color;\n"
								   "}\n"
								   "\n";

	static const glw::GLfloat positions_data[] = { -1.0f, 1.0f,  -1.0f, 1.0f, 3.0f, 3.0f,  3.0f, 3.0f,
												   -1.0f, -1.0f, -1.0f, 1.0f, 3.0f, -3.0f, 3.0f, 3.0f };
	static const glw::GLubyte colors_data[] = { 0xff, 0x00, 0x00, 0xff, 0x00, 0xff, 0x00, 0xff,
												0x00, 0x00, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff };

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

	static const char* shaders[][2] = { { vs_noperspective, fs_noperspective },
										{ vs_default, fs_default },
										{ vs_flat, fs_flat },
										{ vs_smooth, fs_smooth } };
	static const size_t		  n_shaders			= sizeof(shaders) / sizeof(shaders[0]);
	static const size_t		  noperspective_idx = 0;
	static const glw::GLsizei w					= 64;
	static const glw::GLsizei h					= 64;
	static const glw::GLsizei image_length		= w * h;

	bool test_result = true;

	glw::GLuint po_ids[n_shaders]  = { 0 };
	glw::GLuint tex_ids[n_shaders] = { 0 };
	glw::GLuint fbo_ids[n_shaders] = { 0 };
	glw::GLuint vab_id			   = 0;
	glw::GLuint vao_id			   = 0;

	try
	{
		/* Buffer */
		gl.genBuffers(1, &vab_id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GenBuffers");

		gl.bindBuffer(GL_ARRAY_BUFFER, vab_id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "BindBuffer");

		gl.bufferData(GL_ARRAY_BUFFER, sizeof(colors_data) + sizeof(positions_data), 0 /* data */, GL_STATIC_DRAW);
		GLU_EXPECT_NO_ERROR(gl.getError(), "BufferData");

		gl.bufferSubData(GL_ARRAY_BUFFER, 0 /* offset */, sizeof(positions_data) /* size */, positions_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "BufferSubData");

		gl.bufferSubData(GL_ARRAY_BUFFER, sizeof(positions_data) /* offset */, sizeof(colors_data) /* size */,
						 colors_data);
		GLU_EXPECT_NO_ERROR(gl.getError(), "BufferSubData");

		/* FBOs */
		gl.genFramebuffers(n_shaders, fbo_ids);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GenFramebuffers");

		/* Textures */
		gl.genTextures(n_shaders, tex_ids);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GenTextures");

		/* VAO */
		gl.genVertexArrays(1, &vao_id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "GenVertexArrays");

		gl.bindVertexArray(vao_id);
		GLU_EXPECT_NO_ERROR(gl.getError(), "BindVertexArrays");

		for (size_t i = 0; i < n_shaders; ++i)
		{
			/* Program */
			po_ids[i] = prepare_program(m_context, shaders[i][1], shaders[i][0]);

			/* Texture */
			gl.bindTexture(GL_TEXTURE_2D, tex_ids[i]);
			GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");

			gl.texImage2D(GL_TEXTURE_2D, 0 /* level */, GL_RGBA8, w, h, 0 /* border */, GL_RGBA, GL_UNSIGNED_BYTE,
						  0 /* data */);
			GLU_EXPECT_NO_ERROR(gl.getError(), "TexImage2D");

			gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);

			gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_LEVEL, 0);
			GLU_EXPECT_NO_ERROR(gl.getError(), "TexParameteri");

			/* FBO */
			gl.bindFramebuffer(GL_FRAMEBUFFER, fbo_ids[i]);
			GLU_EXPECT_NO_ERROR(gl.getError(), "BindFramebuffer");

			gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex_ids[i], 0 /* level */);
			GLU_EXPECT_NO_ERROR(gl.getError(), "FramebufferTexture2D");

			/* Viewport */
			gl.viewport(0, 0, w, h);
			GLU_EXPECT_NO_ERROR(gl.getError(), "Viewport");

			/* VAO */
			glw::GLint in_position_loc = gl.getAttribLocation(po_ids[i], "in_position");
			glw::GLint in_color_loc	= gl.getAttribLocation(po_ids[i], "in_color");
			GLU_EXPECT_NO_ERROR(gl.getError(), "GetAttribLocation");
			if ((-1 == in_position_loc) || (-1 == in_color_loc))
			{
				TCU_FAIL("Attributes are not available");
			}

			gl.vertexAttribPointer(in_position_loc, 4 /* size */, GL_FLOAT, GL_FALSE /* normalizeed */, 0 /* stride */,
								   0 /* offset */);
			GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribPointer");

			gl.vertexAttribPointer(in_color_loc, 4 /* size */, GL_UNSIGNED_BYTE, GL_TRUE /* normalizeed */,
								   0 /* stride */, (glw::GLvoid*)sizeof(positions_data) /* offset */);
			GLU_EXPECT_NO_ERROR(gl.getError(), "VertexAttribPointer");

			gl.enableVertexAttribArray(in_position_loc);
			GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray");

			gl.enableVertexAttribArray(in_color_loc);
			GLU_EXPECT_NO_ERROR(gl.getError(), "EnableVertexAttribArray");

			/* Clear */
			gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
			GLU_EXPECT_NO_ERROR(gl.getError(), "ClearColor");

			gl.clear(GL_COLOR_BUFFER_BIT);
			GLU_EXPECT_NO_ERROR(gl.getError(), "Clear");

			/* Activate program */
			gl.useProgram(po_ids[i]);
			GLU_EXPECT_NO_ERROR(gl.getError(), "UseProgram");

			/* Draw */
			gl.drawArrays(GL_TRIANGLE_STRIP, 0 /* first */, 4 /* count */);
			GLU_EXPECT_NO_ERROR(gl.getError(), "DrawArrays");

			/* Disable VAO */
			gl.disableVertexAttribArray(in_position_loc);
			GLU_EXPECT_NO_ERROR(gl.getError(), "DisableVertexAttribArray");

			gl.disableVertexAttribArray(in_color_loc);
			GLU_EXPECT_NO_ERROR(gl.getError(), "DisableVertexAttribArray");
		}

		/* Verify results */
		{
			/* Storage for images */
			std::vector<glw::GLuint> fbo_data;
			std::vector<glw::GLuint> noperspective_data;

			fbo_data.resize(image_length);
			noperspective_data.resize(image_length);

			/* Get noperspective image */
			gl.bindTexture(GL_TEXTURE_2D, tex_ids[noperspective_idx]);
			GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");

			gl.getTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &noperspective_data[0]);
			GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage");

			/* Compare noperspective with the rest */
			for (size_t i = 0; i < n_shaders; ++i)
			{
				/* Skip noperspective */
				if (noperspective_idx == i)
				{
					continue;
				}

				gl.bindTexture(GL_TEXTURE_2D, tex_ids[i]);
				GLU_EXPECT_NO_ERROR(gl.getError(), "BindTexture");

				gl.getTexImage(GL_TEXTURE_2D, 0, GL_RGBA, GL_UNSIGNED_BYTE, &fbo_data[0]);
				GLU_EXPECT_NO_ERROR(gl.getError(), "GetTexImage");

				bool are_same = true;

				for (size_t pixel = 0; pixel < image_length; ++pixel)
				{
					const glw::GLuint left  = noperspective_data[pixel];
					const glw::GLuint right = fbo_data[pixel];

					if (left != right)
					{
						are_same = false;
						break;
					}
				}

				if (true == are_same)
				{
					test_result = false;
					break;
				}
			}
		}

		gl.bindBuffer(GL_ARRAY_BUFFER, 0);
		gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
		gl.bindTexture(GL_TEXTURE_2D, 0);
		gl.bindVertexArray(0);
		gl.useProgram(0);

		gl.deleteBuffers(1, &vab_id);
		vab_id = 0;

		gl.deleteVertexArrays(1, &vao_id);
		vao_id = 0;

		gl.deleteFramebuffers(n_shaders, fbo_ids);
		gl.deleteTextures(n_shaders, tex_ids);

		for (size_t idx = 0; idx < n_shaders; ++idx)
		{
			fbo_ids[idx] = 0;
			tex_ids[idx] = 0;
		}

		for (size_t i = 0; i < n_shaders; ++i)
		{
			if (0 != po_ids[i])
			{
				gl.deleteProgram(po_ids[i]);
				po_ids[i] = 0;
			}
		}
	}
	catch (...)
	{
		/* Unbind */
		gl.bindBuffer(GL_ARRAY_BUFFER, 0);

		gl.bindFramebuffer(GL_FRAMEBUFFER, 0);

		gl.bindTexture(GL_TEXTURE_2D, 0);

		gl.bindVertexArray(0);

		gl.useProgram(0);

		/* Delete */
		if (0 != vao_id)
		{
			gl.deleteVertexArrays(1, &vao_id);
		}

		if (0 != vab_id)
		{
			gl.deleteBuffers(1, &vab_id);
		}

		if (0 != fbo_ids[0])
		{
			gl.deleteFramebuffers(n_shaders, fbo_ids);
		}

		for (size_t i = 0; i < n_shaders; ++i)
		{
			if (0 != po_ids[i])
			{
				gl.deleteProgram(po_ids[i]);
			}
		}

		if (0 != tex_ids[0])
		{
			gl.deleteTextures(n_shaders, tex_ids);
		}

		/* Clean any error */
		gl.getError();

		/* Rethrow */
		throw;
	}

	/* Set test result */
	if (true == test_result)
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}

	/* Clean */
	{
		/* Unbind */
		gl.bindBuffer(GL_ARRAY_BUFFER, 0);

		gl.bindFramebuffer(GL_FRAMEBUFFER, 0);

		gl.bindTexture(GL_TEXTURE_2D, 0);

		gl.bindVertexArray(0);

		gl.useProgram(0);

		/* Delete */
		if (0 != vao_id)
		{
			gl.deleteVertexArrays(1, &vao_id);
		}

		if (0 != vab_id)
		{
			gl.deleteBuffers(1, &vab_id);
		}

		if (0 != fbo_ids[0])
		{
			gl.deleteFramebuffers(1, fbo_ids);
		}

		for (size_t i = 0; i < n_shaders; ++i)
		{
			if (0 != po_ids[i])
			{
				gl.deleteProgram(po_ids[i]);
			}
		}

		if (0 != tex_ids[0])
		{
			gl.deleteTextures(1, tex_ids);
		}
	}

	/* Clean any error */
	gl.getError();

	/* Done */
	return STOP;
}

/** Constructor.
 *
 *  @param context Rendering context.
 **/
GLSLnoperspectiveTests::GLSLnoperspectiveTests(deqp::Context& context)
	: TestCaseGroup(context, "glsl_noperspective", "Verifies \"GLSL_noperspective\" functionality")
{
	/* Left blank on purpose */
}

/** Initializes a gpu_shader_5 test group.
 *
 **/
void GLSLnoperspectiveTests::init(void)
{
	addChild(new FunctionalTest(m_context));
}
} /* gl3cts namespace */