external/openglcts/modules/glesext/geometry_shader/esextcGeometryShaderPrimitiveQueries.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 "esextcGeometryShaderPrimitiveQueries.hpp"

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

 namespace glcts
 {

 /* Fragment shader */
 const char* GeometryShaderPrimitiveQueries::m_fs_code = "${VERSION}\n"
 														"\n"
 														"precision highp float;\n"
 														"\n"
 														"void main()\n"
 														"{\n"
 														"}\n";

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

 /* Geometry shader */
 const char* GeometryShaderPrimitiveQueriesPoints::m_gs_code =
 	"${VERSION}\n"
 	"\n"
 	"${GEOMETRY_SHADER_REQUIRE}\n"
 	"\n"
 	"precision highp float;\n"
 	"\n"
 	"layout(points)                          in;\n"
 	"layout(points, max_vertices=8)          out;\n"
 	"\n"
 	"void main()\n"
 	"{\n"
 	"    for (int n = 0; n < 8; ++n)\n"
 	"    {\n"
 	"        gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
 	"        EmitVertex();\n"
 	"    }\n"
 	"\n"
 	"    EndPrimitive();\n"
 	"}\n";

 /* Geometry shader */
 const char* GeometryShaderPrimitiveQueriesLines::m_gs_code =
 	"${VERSION}\n"
 	"\n"
 	"${GEOMETRY_SHADER_REQUIRE}\n"
 	"\n"
 	"precision highp float;\n"
 	"\n"
 	"layout(points)                          in;\n"
 	"layout(line_strip, max_vertices=10)     out;\n"
 	"\n"
 	"void main()\n"
 	"{\n"
 	"    for (int n = 0; n < 10; ++n)\n"
 	"    {\n"
 	"        gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
 	"        EmitVertex();\n"
 	"    }\n"
 	"\n"
 	"    EndPrimitive();\n"
 	"}\n";

 /* Geometry shader */
 const char* GeometryShaderPrimitiveQueriesTriangles::m_gs_code =
 	"${VERSION}\n"
 	"\n"
 	"${GEOMETRY_SHADER_REQUIRE}\n"
 	"\n"
 	"precision highp float;\n"
 	"\n"
 	"layout(points)                          in;\n"
 	"layout(triangle_strip, max_vertices=12) out;\n"
 	"\n"
 	"void main()\n"
 	"{\n"
 	"    for (int n = 0; n < 12; ++n)\n"
 	"    {\n"
 	"        gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
 	"        EmitVertex();\n"
 	"    }\n"
 	"\n"
 	"    EndPrimitive();\n"
 	"}\n";

 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's description
  **/
 GeometryShaderPrimitiveQueriesPoints::GeometryShaderPrimitiveQueriesPoints(Context&				context,
 																		   const ExtParameters& extParams,
 																		   const char* name, const char* description)
 	: GeometryShaderPrimitiveQueries(context, extParams, name, description)
 {
 }

 /** Gets geometry shader code
  *
  * @return geometry shader code
  **/
 const char* GeometryShaderPrimitiveQueriesPoints::getGeometryShaderCode()
 {
 	return m_gs_code;
 }

 /** Gets the number of emitted vertices
  *
  * @return number of emitted vertices
  **/
 glw::GLint GeometryShaderPrimitiveQueriesPoints::getAmountOfEmittedVertices()
 {
 	return 8;
 }

 /** Gets the transform feedback mode
  *
  * @return transform feedback mode
  **/
 glw::GLenum GeometryShaderPrimitiveQueriesPoints::getTFMode()
 {
 	return GL_POINTS;
 }

 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's desricption
  **/
 GeometryShaderPrimitiveQueriesLines::GeometryShaderPrimitiveQueriesLines(Context&			  context,
 																		 const ExtParameters& extParams,
 																		 const char* name, const char* description)
 	: GeometryShaderPrimitiveQueries(context, extParams, name, description)
 {
 }

 /** Gets geometry shader code
  *
  * @return geometry shader code
  **/
 const char* GeometryShaderPrimitiveQueriesLines::getGeometryShaderCode()
 {
 	return m_gs_code;
 }

 /** Gets the number of emitted vertices
  *
  * @return number of emitted vertices
  **/
 glw::GLint GeometryShaderPrimitiveQueriesLines::getAmountOfEmittedVertices()
 {
 	return 18;
 }

 /** Gets the transform feedback mode
  *
  * @return transform feedback mode
  **/
 glw::GLenum GeometryShaderPrimitiveQueriesLines::getTFMode()
 {
 	return GL_LINES;
 }

 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's desricption
  **/
 GeometryShaderPrimitiveQueriesTriangles::GeometryShaderPrimitiveQueriesTriangles(Context&			  context,
 																				 const ExtParameters& extParams,
 																				 const char*		  name,
 																				 const char*		  description)
 	: GeometryShaderPrimitiveQueries(context, extParams, name, description)
 {
 }

 /** Gets geometry shader code
  *
  * @return geometry shader code
  **/
 const char* GeometryShaderPrimitiveQueriesTriangles::getGeometryShaderCode()
 {
 	return m_gs_code;
 }

 /** Gets the number of emitted vertices
  *
  * @return number of emitted vertices
  **/
 glw::GLint GeometryShaderPrimitiveQueriesTriangles::getAmountOfEmittedVertices()
 {
 	return 30;
 }

 /** Gets the transform feedback mode
  *
  * @return transform feedback mode
  **/
 glw::GLenum GeometryShaderPrimitiveQueriesTriangles::getTFMode()
 {
 	return GL_TRIANGLES;
 }

 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's desricption
  **/
 GeometryShaderPrimitiveQueries::GeometryShaderPrimitiveQueries(Context& context, const ExtParameters& extParams,
 															   const char* name, const char* description)
 	: TestCaseBase(context, extParams, name, description)
 	, m_n_texture_components(4)
 	, m_bo_large_id(0)
 	, m_bo_small_id(0)
 	, m_fs_id(0)
 	, m_gs_id(0)
 	, m_po_id(0)
 	, m_qo_primitives_generated_id(0)
 	, m_qo_tf_primitives_written_id(0)
 	, m_vao_id(0)
 	, m_vs_id(0)
 {
 	/* Nothing to be done here */
 }

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

 	/* Reset OpenGL ES state */
 	gl.useProgram(0);
 	gl.bindBuffer(GL_ARRAY_BUFFER, 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_bo_small_id != 0)
 	{
 		gl.deleteBuffers(1, &m_bo_small_id);
 	}

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

 	if (m_qo_primitives_generated_id != 0)
 	{
 		gl.deleteQueries(1, &m_qo_primitives_generated_id);
 	}

 	if (m_qo_tf_primitives_written_id != 0)
 	{
 		gl.deleteQueries(1, &m_qo_tf_primitives_written_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 GeometryShaderPrimitiveQueries::iterate(void)
 {
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	/* Check if geometry_shader extension is supported */
 	if (!m_is_geometry_shader_extension_supported)
 	{
 		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
 	}

 	/* Create shader objects and a program object */
 	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
 	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
 	m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
 	m_po_id = gl.createProgram();

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating program/shader objects.");

 	/* Try to build test-specific program object */
 	const char* tf_varyings[] = { "gl_Position" };
 	const char* gs_code		  = getGeometryShaderCode();

 	gl.transformFeedbackVaryings(m_po_id, sizeof(tf_varyings) / sizeof(tf_varyings[0]), tf_varyings,
 								 GL_SEPARATE_ATTRIBS);

 	if (!buildProgram(m_po_id, m_fs_id, 1 /* part */, &m_fs_code, m_gs_id, 1 /* part */, &gs_code, m_vs_id,
 					  1 /* part */, &m_vs_code))
 	{
 		TCU_FAIL("Could not create a program for GeometryShaderPrimitiveQueries!");
 	}

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

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

 	/* Create two buffer objects
 	 *
 	 * One with sufficiently large storage space to hold position data for particular output.
 	 * Another one of insufficient size.
 	 */
 	gl.genBuffers(1, &m_bo_large_id);
 	gl.genBuffers(1, &m_bo_small_id);

 	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_large_id);
 	gl.bufferData(GL_ARRAY_BUFFER,
 				  getAmountOfEmittedVertices() * m_n_texture_components /* components */ * sizeof(float), NULL,
 				  GL_STATIC_DRAW);

 	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_small_id);
 	gl.bufferData(GL_ARRAY_BUFFER,
 				  (getAmountOfEmittedVertices() / 2) * m_n_texture_components /* components */ * sizeof(float), NULL,
 				  GL_STATIC_DRAW);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error allocating buffer objects.");

 	/* Create primitive query objects */
 	gl.genQueries(1, &m_qo_tf_primitives_written_id);
 	gl.genQueries(1, &m_qo_primitives_generated_id);

 	glw::GLuint nPrimitivesGenerated = 0;
 	glw::GLuint nTFPrimitivesWritten = 0;

 	/* Test case 13.1 */
 	readPrimitiveQueryValues(m_bo_large_id, &nPrimitivesGenerated, &nTFPrimitivesWritten);

 	if (nPrimitivesGenerated == 0)
 	{
 		m_testCtx.getLog()
 			<< tcu::TestLog::Message
 			<< "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value is zero which should never happen."
 			<< tcu::TestLog::EndMessage;

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

 	if (nTFPrimitivesWritten == 0)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query "
 													   "object value is zero which should never happen."
 						   << tcu::TestLog::EndMessage;

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

 	if (nPrimitivesGenerated != nTFPrimitivesWritten)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message << "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value("
 						   << nPrimitivesGenerated
 						   << ") is different than for GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ("
 						   << nTFPrimitivesWritten << ")" << tcu::TestLog::EndMessage;

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

 	/* Test case 13.2 */
 	nPrimitivesGenerated = 0;
 	nTFPrimitivesWritten = 0;

 	readPrimitiveQueryValues(m_bo_small_id, &nPrimitivesGenerated, &nTFPrimitivesWritten);

 	if (nPrimitivesGenerated == 0)
 	{
 		m_testCtx.getLog()
 			<< tcu::TestLog::Message
 			<< "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value is zero which should never happen."
 			<< tcu::TestLog::EndMessage;

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

 	if (nTFPrimitivesWritten == 0)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query "
 													   "object value is zero which should never happen."
 						   << tcu::TestLog::EndMessage;

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

 	if ((nPrimitivesGenerated / 2) != nTFPrimitivesWritten)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message
 						   << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query object value("
 						   << nPrimitivesGenerated << ") should be half the amount of GL_PRIMITIVES_GENERATED_EXT ("
 						   << nTFPrimitivesWritten << ")" << tcu::TestLog::EndMessage;

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

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

 /**
  * The function binds the provided bufferId to transform feedback target and sets up a query
  * for GL_PRIMITIVES_GENERATED_EXT GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN.
  * It then issues a draw call to execute the vertex and geometry shaders. Then results
  * of the queries are written to nPrimitivesGenerated and nPrimitivesWritten variables.
  *
  * @param context bufferId   id of the buffer to be bound to transform feedback target
  * @return nPrimitivesGenerated      the result of GL_PRIMITIVES_GENERATED_EXT query
  * @return nPrimitivesWritten        the result of GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query
  */
 void GeometryShaderPrimitiveQueries::readPrimitiveQueryValues(glw::GLint bufferId, glw::GLuint* nPrimitivesGenerated,
 															  glw::GLuint* nPrimitivesWritten)
 {
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	/* Bind the buffer object to hold the captured data.*/
 	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufferId);

 	/* Activate the program object */
 	gl.useProgram(m_po_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error using program object");

 	gl.beginTransformFeedback(getTFMode());
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting transform feedback");

 	/* Activate the queries */
 	gl.beginQuery(m_glExtTokens.PRIMITIVES_GENERATED, m_qo_primitives_generated_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting GL_PRIMITIVES_GENERATED_EXT query");

 	gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_qo_tf_primitives_written_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query");

 	/* Render */
 	gl.drawArrays(GL_POINTS, 0 /* first */, 1 /* count */);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error executing draw call");

 	gl.endTransformFeedback();
 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error finishing transform feedback");

 	/* Query objects end here. */
 	gl.endQuery(m_glExtTokens.PRIMITIVES_GENERATED);
 	gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);

 	/* Retrieve query values */
 	gl.getQueryObjectuiv(m_qo_primitives_generated_id, GL_QUERY_RESULT, nPrimitivesGenerated);
 	gl.getQueryObjectuiv(m_qo_tf_primitives_written_id, GL_QUERY_RESULT, nPrimitivesWritten);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "Error retrieving query values.");
 }

 } // 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 "esextcGeometryShaderPrimitiveQueries.hpp"

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

	namespace glcts
	{

	/* Fragment shader */
	const char* GeometryShaderPrimitiveQueries::m_fs_code = "${VERSION}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"void main()\n"
	"{\n"
	"}\n";

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

	/* Geometry shader */
	const char* GeometryShaderPrimitiveQueriesPoints::m_gs_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout(points) in;\n"
	"layout(points, max_vertices=8) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" for (int n = 0; n < 8; ++n)\n"
	" {\n"
	" gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
	" EmitVertex();\n"
	" }\n"
	"\n"
	" EndPrimitive();\n"
	"}\n";

	/* Geometry shader */
	const char* GeometryShaderPrimitiveQueriesLines::m_gs_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout(points) in;\n"
	"layout(line_strip, max_vertices=10) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" for (int n = 0; n < 10; ++n)\n"
	" {\n"
	" gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
	" EmitVertex();\n"
	" }\n"
	"\n"
	" EndPrimitive();\n"
	"}\n";

	/* Geometry shader */
	const char* GeometryShaderPrimitiveQueriesTriangles::m_gs_code =
	"${VERSION}\n"
	"\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"layout(points) in;\n"
	"layout(triangle_strip, max_vertices=12) out;\n"
	"\n"
	"void main()\n"
	"{\n"
	" for (int n = 0; n < 12; ++n)\n"
	" {\n"
	" gl_Position = vec4(1.0 / (float(n) + 1.0), 1.0 / (float(n) + 2.0), 0.0, 1.0);\n"
	" EmitVertex();\n"
	" }\n"
	"\n"
	" EndPrimitive();\n"
	"}\n";

	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's description
	**/
	GeometryShaderPrimitiveQueriesPoints::GeometryShaderPrimitiveQueriesPoints(Context& context,
	const ExtParameters& extParams,
	const char* name, const char* description)
	: GeometryShaderPrimitiveQueries(context, extParams, name, description)
	{
	}

	/** Gets geometry shader code
	*
	* @return geometry shader code
	**/
	const char* GeometryShaderPrimitiveQueriesPoints::getGeometryShaderCode()
	{
	return m_gs_code;
	}

	/** Gets the number of emitted vertices
	*
	* @return number of emitted vertices
	**/
	glw::GLint GeometryShaderPrimitiveQueriesPoints::getAmountOfEmittedVertices()
	{
	return 8;
	}

	/** Gets the transform feedback mode
	*
	* @return transform feedback mode
	**/
	glw::GLenum GeometryShaderPrimitiveQueriesPoints::getTFMode()
	{
	return GL_POINTS;
	}

	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's desricption
	**/
	GeometryShaderPrimitiveQueriesLines::GeometryShaderPrimitiveQueriesLines(Context& context,
	const ExtParameters& extParams,
	const char* name, const char* description)
	: GeometryShaderPrimitiveQueries(context, extParams, name, description)
	{
	}

	/** Gets geometry shader code
	*
	* @return geometry shader code
	**/
	const char* GeometryShaderPrimitiveQueriesLines::getGeometryShaderCode()
	{
	return m_gs_code;
	}

	/** Gets the number of emitted vertices
	*
	* @return number of emitted vertices
	**/
	glw::GLint GeometryShaderPrimitiveQueriesLines::getAmountOfEmittedVertices()
	{
	return 18;
	}

	/** Gets the transform feedback mode
	*
	* @return transform feedback mode
	**/
	glw::GLenum GeometryShaderPrimitiveQueriesLines::getTFMode()
	{
	return GL_LINES;
	}

	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's desricption
	**/
	GeometryShaderPrimitiveQueriesTriangles::GeometryShaderPrimitiveQueriesTriangles(Context& context,
	const ExtParameters& extParams,
	const char* name,
	const char* description)
	: GeometryShaderPrimitiveQueries(context, extParams, name, description)
	{
	}

	/** Gets geometry shader code
	*
	* @return geometry shader code
	**/
	const char* GeometryShaderPrimitiveQueriesTriangles::getGeometryShaderCode()
	{
	return m_gs_code;
	}

	/** Gets the number of emitted vertices
	*
	* @return number of emitted vertices
	**/
	glw::GLint GeometryShaderPrimitiveQueriesTriangles::getAmountOfEmittedVertices()
	{
	return 30;
	}

	/** Gets the transform feedback mode
	*
	* @return transform feedback mode
	**/
	glw::GLenum GeometryShaderPrimitiveQueriesTriangles::getTFMode()
	{
	return GL_TRIANGLES;
	}

	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's desricption
	**/
	GeometryShaderPrimitiveQueries::GeometryShaderPrimitiveQueries(Context& context, const ExtParameters& extParams,
	const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_n_texture_components(4)
	, m_bo_large_id(0)
	, m_bo_small_id(0)
	, m_fs_id(0)
	, m_gs_id(0)
	, m_po_id(0)
	, m_qo_primitives_generated_id(0)
	, m_qo_tf_primitives_written_id(0)
	, m_vao_id(0)
	, m_vs_id(0)
	{
	/* Nothing to be done here */
	}

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

	/* Reset OpenGL ES state */
	gl.useProgram(0);
	gl.bindBuffer(GL_ARRAY_BUFFER, 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_bo_small_id != 0)
	{
	gl.deleteBuffers(1, &m_bo_small_id);
	}

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

	if (m_qo_primitives_generated_id != 0)
	{
	gl.deleteQueries(1, &m_qo_primitives_generated_id);
	}

	if (m_qo_tf_primitives_written_id != 0)
	{
	gl.deleteQueries(1, &m_qo_tf_primitives_written_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 GeometryShaderPrimitiveQueries::iterate(void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Check if geometry_shader extension is supported */
	if (!m_is_geometry_shader_extension_supported)
	{
	throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* Create shader objects and a program object */
	m_vs_id = gl.createShader(GL_VERTEX_SHADER);
	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
	m_gs_id = gl.createShader(m_glExtTokens.GEOMETRY_SHADER);
	m_po_id = gl.createProgram();

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error creating program/shader objects.");

	/* Try to build test-specific program object */
	const char* tf_varyings[] = { "gl_Position" };
	const char* gs_code = getGeometryShaderCode();

	gl.transformFeedbackVaryings(m_po_id, sizeof(tf_varyings) / sizeof(tf_varyings[0]), tf_varyings,
	GL_SEPARATE_ATTRIBS);

	if (!buildProgram(m_po_id, m_fs_id, 1 /* part /, &m_fs_code, m_gs_id, 1 / part */, &gs_code, m_vs_id,
	1 /* part */, &m_vs_code))
	{
	TCU_FAIL("Could not create a program for GeometryShaderPrimitiveQueries!");
	}

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

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

	/* Create two buffer objects
	*
	* One with sufficiently large storage space to hold position data for particular output.
	* Another one of insufficient size.
	*/
	gl.genBuffers(1, &m_bo_large_id);
	gl.genBuffers(1, &m_bo_small_id);

	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_large_id);
	gl.bufferData(GL_ARRAY_BUFFER,
	getAmountOfEmittedVertices() * m_n_texture_components /* components / sizeof(float), NULL,
	GL_STATIC_DRAW);

	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_small_id);
	gl.bufferData(GL_ARRAY_BUFFER,
	(getAmountOfEmittedVertices() / 2) * m_n_texture_components /* components / sizeof(float), NULL,
	GL_STATIC_DRAW);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error allocating buffer objects.");

	/* Create primitive query objects */
	gl.genQueries(1, &m_qo_tf_primitives_written_id);
	gl.genQueries(1, &m_qo_primitives_generated_id);

	glw::GLuint nPrimitivesGenerated = 0;
	glw::GLuint nTFPrimitivesWritten = 0;

	/* Test case 13.1 */
	readPrimitiveQueryValues(m_bo_large_id, &nPrimitivesGenerated, &nTFPrimitivesWritten);

	if (nPrimitivesGenerated == 0)
	{
	m_testCtx.getLog()
	<< tcu::TestLog::Message
	<< "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value is zero which should never happen."
	<< tcu::TestLog::EndMessage;

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

	if (nTFPrimitivesWritten == 0)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query "
	"object value is zero which should never happen."
	<< tcu::TestLog::EndMessage;

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

	if (nPrimitivesGenerated != nTFPrimitivesWritten)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value("
	<< nPrimitivesGenerated
	<< ") is different than for GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN ("
	<< nTFPrimitivesWritten << ")" << tcu::TestLog::EndMessage;

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

	/* Test case 13.2 */
	nPrimitivesGenerated = 0;
	nTFPrimitivesWritten = 0;

	readPrimitiveQueryValues(m_bo_small_id, &nPrimitivesGenerated, &nTFPrimitivesWritten);

	if (nPrimitivesGenerated == 0)
	{
	m_testCtx.getLog()
	<< tcu::TestLog::Message
	<< "Retrieved GL_PRIMITIVES_GENERATED_EXT query object value is zero which should never happen."
	<< tcu::TestLog::EndMessage;

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

	if (nTFPrimitivesWritten == 0)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query "
	"object value is zero which should never happen."
	<< tcu::TestLog::EndMessage;

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

	if ((nPrimitivesGenerated / 2) != nTFPrimitivesWritten)
	{
	m_testCtx.getLog() << tcu::TestLog::Message
	<< "Retrieved GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query object value("
	<< nPrimitivesGenerated << ") should be half the amount of GL_PRIMITIVES_GENERATED_EXT ("
	<< nTFPrimitivesWritten << ")" << tcu::TestLog::EndMessage;

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

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

	/**
	* The function binds the provided bufferId to transform feedback target and sets up a query
	* for GL_PRIMITIVES_GENERATED_EXT GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN.
	* It then issues a draw call to execute the vertex and geometry shaders. Then results
	* of the queries are written to nPrimitivesGenerated and nPrimitivesWritten variables.
	*
	* @param context bufferId id of the buffer to be bound to transform feedback target
	* @return nPrimitivesGenerated the result of GL_PRIMITIVES_GENERATED_EXT query
	* @return nPrimitivesWritten the result of GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query
	*/
	void GeometryShaderPrimitiveQueries::readPrimitiveQueryValues(glw::GLint bufferId, glw::GLuint* nPrimitivesGenerated,
	glw::GLuint* nPrimitivesWritten)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Bind the buffer object to hold the captured data.*/
	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, bufferId);

	/* Activate the program object */
	gl.useProgram(m_po_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error using program object");

	gl.beginTransformFeedback(getTFMode());
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting transform feedback");

	/* Activate the queries */
	gl.beginQuery(m_glExtTokens.PRIMITIVES_GENERATED, m_qo_primitives_generated_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting GL_PRIMITIVES_GENERATED_EXT query");

	gl.beginQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN, m_qo_tf_primitives_written_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error starting GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN query");

	/* Render */
	gl.drawArrays(GL_POINTS, 0 /* first /, 1 / count */);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error executing draw call");

	gl.endTransformFeedback();
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error finishing transform feedback");

	/* Query objects end here. */
	gl.endQuery(m_glExtTokens.PRIMITIVES_GENERATED);
	gl.endQuery(GL_TRANSFORM_FEEDBACK_PRIMITIVES_WRITTEN);

	/* Retrieve query values */
	gl.getQueryObjectuiv(m_qo_primitives_generated_id, GL_QUERY_RESULT, nPrimitivesGenerated);
	gl.getQueryObjectuiv(m_qo_tf_primitives_written_id, GL_QUERY_RESULT, nPrimitivesWritten);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error retrieving query values.");
	}

	} // namespace glcts