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

 /*-------------------------------------------------------------------------
  * 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
  */ /*-------------------------------------------------------------------*/
 #include "gluDefs.hpp"
 #include "glwEnums.hpp"
 #include "glwFunctions.hpp"
 #include "tcuTestLog.hpp"
 #include <math.h>
 #include <string.h>

 #include "esextcGeometryShaderQualifiers.hpp"

 namespace glcts
 {
 /** Constructor
  *
  * @param context       Test context
  * @param name          Test case's name
  * @param description   Test case's desricption
  **/
 GeometryShaderFlatInterpolationTest::GeometryShaderFlatInterpolationTest(Context&			  context,
 																		 const ExtParameters& extParams,
 																		 const char* name, const char* description)
 	: TestCaseBase(context, extParams, name, description)
 	, m_bo_id(0)
 	, m_fs_id(0)
 	, m_gs_id(0)
 	, m_po_id(0)
 	, m_vao_id(0)
 	, m_vs_id(0)
 {
 	/* Nothing to be done here */
 }

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

 	/* Deinitialize ES objects */
 	if (m_bo_id != 0)
 	{
 		gl.deleteBuffers(1, &m_bo_id);

 		m_bo_id = 0;
 	}

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

 		m_fs_id = 0;
 	}

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

 		m_gs_id = 0;
 	}

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

 		m_po_id = 0;
 	}

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

 		m_vao_id = 0;
 	}

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

 		m_vs_id = 0;
 	}

 	/* Deinitialize base implementation */
 	TestCaseBase::deinit();
 }

 /* Initializes a program object to be used for the conformance test. */
 void GeometryShaderFlatInterpolationTest::initProgram()
 {
 	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

 	/* Create shader objects */
 	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
 	m_gs_id = gl.createShader(GL_GEOMETRY_SHADER);
 	m_vs_id = gl.createShader(GL_VERTEX_SHADER);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed.");

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

 	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed.");

 	/* Set the test program object up */
 	static const char* fs_code_raw = "${VERSION}\n"
 									 "\n"
 									 "precision highp float;\n"
 									 "\n"
 									 "out vec4 result;\n"
 									 "\n"
 									 "void main()\n"
 									 "{\n"
 									 "    result = vec4(1.0);\n"
 									 "}\n";

 	static const char* gs_code_raw = "${VERSION}\n"
 									 "${GEOMETRY_SHADER_REQUIRE}\n"
 									 "\n"
 									 "layout(triangles)                in;\n"
 									 "layout(points, max_vertices = 1) out;\n"
 									 "\n"
 									 "flat in int out_vertex[];\n"
 									 "\n"
 									 "void main()\n"
 									 "{\n"
 									 "    if (out_vertex[0] != 0 || out_vertex[1] != 1 || out_vertex[2] != 2)\n"
 									 "    {\n"
 									 "        gl_Position = vec4(0.0);\n"
 									 "    }\n"
 									 "    else\n"
 									 "    {\n"
 									 "        gl_Position = vec4(1.0);\n"
 									 "    }\n"
 									 "    EmitVertex();\n"
 									 "}\n";

 	static const char* po_varying  = "gl_Position";
 	static const char* vs_code_raw = "${VERSION}\n"
 									 "\n"
 									 "flat out int out_vertex;\n"
 									 "\n"
 									 "void main()\n"
 									 "{\n"
 									 "    gl_Position = vec4(0.0);\n"
 									 "    out_vertex  = gl_VertexID;\n"
 									 "}\n";

 	std::string fs_code_specialized = TestCaseBase::specializeShader(1, /* parts */
 																	 &fs_code_raw);
 	const char* fs_code_specialized_raw = fs_code_specialized.c_str();
 	std::string gs_code_specialized		= TestCaseBase::specializeShader(1, /* parts */
 																	 &gs_code_raw);
 	const char* gs_code_specialized_raw = gs_code_specialized.c_str();
 	std::string vs_code_specialized		= TestCaseBase::specializeShader(1, /* parts */
 																	 &vs_code_raw);
 	const char* vs_code_specialized_raw = vs_code_specialized.c_str();

 	gl.transformFeedbackVaryings(m_po_id, 1, /* count */
 								 &po_varying, GL_INTERLEAVED_ATTRIBS);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed.");

 	if (!TestCaseBase::buildProgram(m_po_id, m_gs_id, 1,				  /* n_sh1_body_parts */
 									&gs_code_specialized_raw, m_vs_id, 1, /* n_sh2_body_parts */
 									&vs_code_specialized_raw, m_fs_id, 1, /* n_sh3_body_parts */
 									&fs_code_specialized_raw))
 	{
 		TCU_FAIL("Could not build test program 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::TestNode::IterateResult GeometryShaderFlatInterpolationTest::iterate(void)
 {
 	const glw::Functions& gl	 = m_context.getRenderContext().getFunctions();
 	bool				  result = true;

 	/* This test should only run if EXT_geometry_shader is supported. */
 	if (!m_is_geometry_shader_extension_supported)
 	{
 		throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
 	}

 	/* Set up the buffer object */
 	gl.genBuffers(1, &m_bo_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed.");

 	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

 	gl.bufferData(GL_ARRAY_BUFFER, sizeof(float) * 4, /* components */
 				  DE_NULL,							  /* data */
 				  GL_STATIC_DRAW);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");

 	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* index */
 					  m_bo_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed.");

 	/* Set up the vertex array object */
 	gl.genVertexArrays(1, &m_vao_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");

 	gl.bindVertexArray(m_vao_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");

 	/* Set up the test program */
 	initProgram();

 	gl.useProgram(m_po_id);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");

 	gl.beginTransformFeedback(GL_POINTS);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed.");

 	/* Draw the input triangle */
 	gl.drawArrays(GL_TRIANGLES, 0, /* first */
 				  3);			   /* count */
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");

 	gl.endTransformFeedback();
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed.");

 	/* Map the BO contents to the process space */
 	const float* result_bo_data = (const float*)gl.mapBufferRange(GL_ARRAY_BUFFER, 0, /* offset */
 																  sizeof(float) * 4, GL_MAP_READ_BIT);

 	GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed.");

 	if (fabs(result_bo_data[0] - 1.0f) >= 1e-5f || fabs(result_bo_data[1] - 1.0f) >= 1e-5f ||
 		fabs(result_bo_data[2] - 1.0f) >= 1e-5f || fabs(result_bo_data[3] - 1.0f) >= 1e-5f)
 	{
 		m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel data was retrieved." << tcu::TestLog::EndMessage;

 		result = false;
 	}

 	gl.unmapBuffer(GL_ARRAY_BUFFER);
 	GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed.");

 	/* All done */
 	if (result)
 	{
 		m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 	}
 	else
 	{
 		m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 	}

 	return STOP;
 }

 } // namespace glcts
	/*-------------------------------------------------------------------------
	* 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
	/ /-------------------------------------------------------------------*/
	#include "gluDefs.hpp"
	#include "glwEnums.hpp"
	#include "glwFunctions.hpp"
	#include "tcuTestLog.hpp"
	#include <math.h>
	#include <string.h>

	#include "esextcGeometryShaderQualifiers.hpp"

	namespace glcts
	{
	/** Constructor
	*
	* @param context Test context
	* @param name Test case's name
	* @param description Test case's desricption
	**/
	GeometryShaderFlatInterpolationTest::GeometryShaderFlatInterpolationTest(Context& context,
	const ExtParameters& extParams,
	const char* name, const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_bo_id(0)
	, m_fs_id(0)
	, m_gs_id(0)
	, m_po_id(0)
	, m_vao_id(0)
	, m_vs_id(0)
	{
	/* Nothing to be done here */
	}

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

	/* Deinitialize ES objects */
	if (m_bo_id != 0)
	{
	gl.deleteBuffers(1, &m_bo_id);

	m_bo_id = 0;
	}

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

	m_fs_id = 0;
	}

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

	m_gs_id = 0;
	}

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

	m_po_id = 0;
	}

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

	m_vao_id = 0;
	}

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

	m_vs_id = 0;
	}

	/* Deinitialize base implementation */
	TestCaseBase::deinit();
	}

	/* Initializes a program object to be used for the conformance test. */
	void GeometryShaderFlatInterpolationTest::initProgram()
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Create shader objects */
	m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
	m_gs_id = gl.createShader(GL_GEOMETRY_SHADER);
	m_vs_id = gl.createShader(GL_VERTEX_SHADER);

	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call(s) failed.");

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

	GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed.");

	/* Set the test program object up */
	static const char* fs_code_raw = "${VERSION}\n"
	"\n"
	"precision highp float;\n"
	"\n"
	"out vec4 result;\n"
	"\n"
	"void main()\n"
	"{\n"
	" result = vec4(1.0);\n"
	"}\n";

	static const char* gs_code_raw = "${VERSION}\n"
	"${GEOMETRY_SHADER_REQUIRE}\n"
	"\n"
	"layout(triangles) in;\n"
	"layout(points, max_vertices = 1) out;\n"
	"\n"
	"flat in int out_vertex[];\n"
	"\n"
	"void main()\n"
	"{\n"
	" if (out_vertex[0] != 0 \|\| out_vertex[1] != 1 \|\| out_vertex[2] != 2)\n"
	" {\n"
	" gl_Position = vec4(0.0);\n"
	" }\n"
	" else\n"
	" {\n"
	" gl_Position = vec4(1.0);\n"
	" }\n"
	" EmitVertex();\n"
	"}\n";

	static const char* po_varying = "gl_Position";
	static const char* vs_code_raw = "${VERSION}\n"
	"\n"
	"flat out int out_vertex;\n"
	"\n"
	"void main()\n"
	"{\n"
	" gl_Position = vec4(0.0);\n"
	" out_vertex = gl_VertexID;\n"
	"}\n";

	std::string fs_code_specialized = TestCaseBase::specializeShader(1, /* parts */
	&fs_code_raw);
	const char* fs_code_specialized_raw = fs_code_specialized.c_str();
	std::string gs_code_specialized = TestCaseBase::specializeShader(1, /* parts */
	&gs_code_raw);
	const char* gs_code_specialized_raw = gs_code_specialized.c_str();
	std::string vs_code_specialized = TestCaseBase::specializeShader(1, /* parts */
	&vs_code_raw);
	const char* vs_code_specialized_raw = vs_code_specialized.c_str();

	gl.transformFeedbackVaryings(m_po_id, 1, /* count */
	&po_varying, GL_INTERLEAVED_ATTRIBS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed.");

	if (!TestCaseBase::buildProgram(m_po_id, m_gs_id, 1, /* n_sh1_body_parts */
	&gs_code_specialized_raw, m_vs_id, 1, /* n_sh2_body_parts */
	&vs_code_specialized_raw, m_fs_id, 1, /* n_sh3_body_parts */
	&fs_code_specialized_raw))
	{
	TCU_FAIL("Could not build test program 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::TestNode::IterateResult GeometryShaderFlatInterpolationTest::iterate(void)
	{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();
	bool result = true;

	/* This test should only run if EXT_geometry_shader is supported. */
	if (!m_is_geometry_shader_extension_supported)
	{
	throw tcu::NotSupportedError(GEOMETRY_SHADER_EXTENSION_NOT_SUPPORTED, "", __FILE__, __LINE__);
	}

	/* Set up the buffer object */
	gl.genBuffers(1, &m_bo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed.");

	gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");

	gl.bufferData(GL_ARRAY_BUFFER, sizeof(float) * 4, /* components */
	DE_NULL, /* data */
	GL_STATIC_DRAW);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");

	gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* index */
	m_bo_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBufferBase() call failed.");

	/* Set up the vertex array object */
	gl.genVertexArrays(1, &m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");

	gl.bindVertexArray(m_vao_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");

	/* Set up the test program */
	initProgram();

	gl.useProgram(m_po_id);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");

	gl.beginTransformFeedback(GL_POINTS);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed.");

	/* Draw the input triangle */
	gl.drawArrays(GL_TRIANGLES, 0, /* first */
	3); /* count */
	GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");

	gl.endTransformFeedback();
	GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed.");

	/* Map the BO contents to the process space */
	const float* result_bo_data = (const float)gl.mapBufferRange(GL_ARRAY_BUFFER, 0, / offset */
	sizeof(float) * 4, GL_MAP_READ_BIT);

	GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed.");

	if (fabs(result_bo_data[0] - 1.0f) >= 1e-5f \|\| fabs(result_bo_data[1] - 1.0f) >= 1e-5f \|\|
	fabs(result_bo_data[2] - 1.0f) >= 1e-5f \|\| fabs(result_bo_data[3] - 1.0f) >= 1e-5f)
	{
	m_testCtx.getLog() << tcu::TestLog::Message << "Invalid texel data was retrieved." << tcu::TestLog::EndMessage;

	result = false;
	}

	gl.unmapBuffer(GL_ARRAY_BUFFER);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed.");

	/* All done */
	if (result)
	{
	m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
	}
	else
	{
	m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
	}

	return STOP;
	}

	} // namespace glcts