external/openglcts/modules/glesext/geometry_shader/esextcGeometryShaderClipping.cpp - third_party/vulkan-cts - Git at Google

 /*-------------------------------------------------------------------------
  * 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 "esextcGeometryShaderClipping.hpp"

 #include "gluDefs.hpp"
 #include "glwEnums.hpp"
 #include "glwFunctions.hpp"
 #include "tcuTestLog.hpp"
 #include <cstring>

 namespace glcts
 {
 /* Fragment shader code */
 const char* GeometryShaderClipping::m_fs_code = "${VERSION}\n"
 												"\n"
 												"precision highp float;\n"
 												"\n"
 												"out vec4 result;\n"
 												"\n"
 												"void main()\n"
 												"{\n"
 												"    result = vec4(0, 1, 0, 0);\n"
 												"}\n";

 /* Vertex shader code */
 const char* GeometryShaderClipping::m_vs_code = "${VERSION}\n"
 												"\n"
 												"precision highp float;\n"
 												"\n"
 												"void main()\n"
 												"{\n"
 												"    gl_Position = vec4(-10, -10, -10, 0);\n"
 												"}\n";

 /* Geometry shader code */
 const char* GeometryShaderClipping::m_gs_code = "${VERSION}\n"
 												"${GEOMETRY_SHADER_REQUIRE}\n"
 												"\n"
 												"precision highp float;\n"
 												"\n"
 												"layout(points)                                    in;\n"
 												"layout(triangle_strip, max_vertices=4) out;\n"
 												"\n"
 												"void main()\n"
 												"{\n"
 												"\n"
 												"    gl_Position = vec4(1, 1, 0, 1);\n"
 												"    EmitVertex();\n"
 												"\n"
 												"    gl_Position = vec4(1, -1, 0, 1);\n"
 												"    EmitVertex();\n"
 												"\n"
 												"    gl_Position = vec4(-1, 1, 0, 1);\n"
 												"    EmitVertex();\n"
 												"\n"
 												"    gl_Position = vec4(-1, -1, 0, 1);\n"
 												"    EmitVertex();\n"
 												"\n"
 												"    EndPrimitive();\n"
 												"}\n";

 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's desricption
  **/
 GeometryShaderClipping::GeometryShaderClipping(Context& context, const ExtParameters& extParams, const char* name,
 											   const char* description)
 	: TestCaseBase(context, extParams, name, description)
 	, m_fbo_id(0)
 	, m_fs_id(0)
 	, m_gs_id(0)
 	, m_po_id(0)
 	, m_to_id(0)
 	, m_vao_id(0)
 	, m_vs_id(0)
 {
 }

 /** Deinitializes GLES objects created during the test.
  *
  */
 void GeometryShaderClipping::deinit(void)
 {
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	/* Reset OpenGL ES state */
 	gl.useProgram(0);
 	gl.bindTexture(GL_TEXTURE_2D, 0);
 	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
 	gl.bindVertexArray(0);

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

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

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

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

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

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

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

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

 /** 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::TestNode::IterateResult GeometryShaderClipping::iterate(void)
 {
 	unsigned char buffer[m_texture_width * m_texture_height * m_texture_n_components];

 	const glw::Functions& gl				= m_context.getRenderContext().getFunctions();
 	const unsigned char   reference_color[] = { 0, 255, 0, 0 };
 	const unsigned int	row_size			= m_texture_width * m_texture_n_components;

 	if (!m_is_geometry_shader_extension_supported)
 	{
 		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
 	}

 	/* Create shader objects we'll need */
 	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
 	m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
 	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
 	m_po_id = gl.createProgram();

 	if (!buildProgram(m_po_id, m_fs_id, 1 /* part */, &m_fs_code, m_gs_id, 1 /* part */, &m_gs_code, m_vs_id,
 					  1 /* part */, &m_vs_code))
 	{
 		TCU_FAIL("Could not create program object from valid vertex/geometry/fragment shaders!");
 	}

 	/* Create and configure texture object we'll be rendering to */
 	gl.genTextures(1, &m_to_id);
 	gl.bindTexture(GL_TEXTURE_2D, m_to_id);
 	gl.texStorage2D(GL_TEXTURE_2D, m_texture_n_levels, GL_RGBA8, m_texture_width, m_texture_height);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating texture object!");

 	/* Create and configure the framebuffer object */
 	gl.genFramebuffers(1, &m_fbo_id);
 	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo_id);
 	gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring framebuffer object!");

 	/* Create and bind vertex array object */
 	gl.genVertexArrays(1, &m_vao_id);
 	gl.bindVertexArray(m_vao_id);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring vertex array object");

 	/* Render */
 	gl.viewport(0 /* x */, 0 /* y */, m_texture_width /* width */, m_texture_height /* height */);
 	gl.useProgram(m_po_id);

 	gl.clearColor(1.0f, 0.0f, 0.0f, 0.0f);
 	gl.clear(GL_COLOR_BUFFER_BIT);

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

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Rendering failed!");

 	/* Read the rendered data */
 	gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_id);
 	gl.readPixels(0 /* x */, 0 /* y */, m_texture_height /* width */, m_texture_width /* height */, GL_RGBA,
 				  GL_UNSIGNED_BYTE, buffer);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels failed!");

 	/* Loop over all pixels and compare the rendered data with reference value */
 	for (int y = 0; y < m_texture_height; ++y)
 	{
 		unsigned char* data_row = buffer + y * row_size;

 		for (int x = 0; x < m_texture_width; ++x)
 		{
 			unsigned char* data = data_row + x * m_texture_n_components;

 			if (memcmp(data, reference_color, sizeof(reference_color)) != 0)
 			{
 				m_testCtx.getLog() << tcu::TestLog::Message << "Rendered data [" << data[0] << ", " << data[1] << ", "
 								   << data[2] << ", " << data[3] << "] is different from reference data ["
 								   << reference_color[0] << ", " << reference_color[1] << ", " << reference_color[2]
 								   << ", " << reference_color[3] << "] !" << tcu::TestLog::EndMessage;

 				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");

 				return STOP;
 			} /* if (memcmp(data, reference_color, sizeof(reference_color)) != 0) */
 		}	 /* for (all columns) */
 	}		  /* for (all rows) */

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

 } // namespace glcts
	/*-------------------------------------------------------------------------
	* 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 "esextcGeometryShaderClipping.hpp"

	#include "gluDefs.hpp"
	#include "glwEnums.hpp"
	#include "glwFunctions.hpp"
	#include "tcuTestLog.hpp"
	#include <cstring>

	namespace glcts
	{
	/* Fragment shader code */
	const char* GeometryShaderClipping::m_fs_code = "${VERSION}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"out vec4 result;\n"
	"\n"
	"void main()\n"
	"{\n"
	" result = vec4(0, 1, 0, 0);\n"
	"}\n";

	/* Vertex shader code */
	const char* GeometryShaderClipping::m_vs_code = "${VERSION}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_Position = vec4(-10, -10, -10, 0);\n"
	"}\n";

	/* Geometry shader code */
	const char* GeometryShaderClipping::m_gs_code = "${VERSION}\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout(points) in;\n"
	"layout(triangle_strip, max_vertices=4) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	"\n"
	" gl_Position = vec4(1, 1, 0, 1);\n"
	" EmitVertex();\n"
	"\n"
	" gl_Position = vec4(1, -1, 0, 1);\n"
	" EmitVertex();\n"
	"\n"
	" gl_Position = vec4(-1, 1, 0, 1);\n"
	" EmitVertex();\n"
	"\n"
	" gl_Position = vec4(-1, -1, 0, 1);\n"
	" EmitVertex();\n"
	"\n"
	" EndPrimitive();\n"
	"}\n";

	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's desricption
	**/
	GeometryShaderClipping::GeometryShaderClipping(Context& context, const ExtParameters& extParams, const char* name,
	const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_fbo_id(0)
	, m_fs_id(0)
	, m_gs_id(0)
	, m_po_id(0)
	, m_to_id(0)
	, m_vao_id(0)
	, m_vs_id(0)
	{
	}

	/** Deinitializes GLES objects created during the test.
	*
	*/
	void GeometryShaderClipping::deinit(void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Reset OpenGL ES state */
	gl.useProgram(0);
	gl.bindTexture(GL_TEXTURE_2D, 0);
	gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
	gl.bindVertexArray(0);

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

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

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

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

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

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

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

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

	/** 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::TestNode::IterateResult GeometryShaderClipping::iterate(void)
	{
	unsigned char buffer[m_texture_width * m_texture_height * m_texture_n_components];

	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
	const unsigned char reference_color[] = { 0, 255, 0, 0 };
	const unsigned int row_size = m_texture_width * m_texture_n_components;

	if (!m_is_geometry_shader_extension_supported)
	{
	throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* Create shader objects we'll need */
	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
	m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
	m_po_id = gl.createProgram();

	if (!buildProgram(m_po_id, m_fs_id, 1 /* part /, &m_fs_code, m_gs_id, 1 / part */, &m_gs_code, m_vs_id,
	1 /* part */, &m_vs_code))
	{
	TCU_FAIL("Could not create program object from valid vertex/geometry/fragment shaders!");
	}

	/* Create and configure texture object we'll be rendering to */
	gl.genTextures(1, &m_to_id);
	gl.bindTexture(GL_TEXTURE_2D, m_to_id);
	gl.texStorage2D(GL_TEXTURE_2D, m_texture_n_levels, GL_RGBA8, m_texture_width, m_texture_height);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating texture object!");

	/* Create and configure the framebuffer object */
	gl.genFramebuffers(1, &m_fbo_id);
	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo_id);
	gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0 /* level */);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring framebuffer object!");

	/* Create and bind vertex array object */
	gl.genVertexArrays(1, &m_vao_id);
	gl.bindVertexArray(m_vao_id);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error configuring vertex array object");

	/* Render */
	gl.viewport(0 /* x /, 0 / y /, m_texture_width / width /, m_texture_height / height */);
	gl.useProgram(m_po_id);

	gl.clearColor(1.0f, 0.0f, 0.0f, 0.0f);
	gl.clear(GL_COLOR_BUFFER_BIT);

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

	GLU_EXPECT_NO_ERROR(gl.getError(), "Rendering failed!");

	/* Read the rendered data */
	gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_id);
	gl.readPixels(0 /* x /, 0 / y /, m_texture_height / width /, m_texture_width / height */, GL_RGBA,
	GL_UNSIGNED_BYTE, buffer);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels failed!");

	/* Loop over all pixels and compare the rendered data with reference value */
	for (int y = 0; y < m_texture_height; ++y)
	{
	unsigned char* data_row = buffer + y * row_size;

	for (int x = 0; x < m_texture_width; ++x)
	{
	unsigned char* data = data_row + x * m_texture_n_components;

	if (memcmp(data, reference_color, sizeof(reference_color)) != 0)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Rendered data [" << data[0] << ", " << data[1] << ", "
	<< data[2] << ", " << data[3] << "] is different from reference data ["
	<< reference_color[0] << ", " << reference_color[1] << ", " << reference_color[2]
	<< ", " << reference_color[3] << "] !" << tcu::TestLog::EndMessage;

	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");

	return STOP;
	} /* if (memcmp(data, reference_color, sizeof(reference_color)) != 0) */
	} /* for (all columns) */
	} /* for (all rows) */

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

	} // namespace glcts