xref: /third_party/vk-gl-cts/external/openglcts/modules/glesext/tessellation_shader/esextcTessellationShaderWinding.cpp

/*-------------------------------------------------------------------------
 * OpenGL Conformance Test Suite
 * -----------------------------
 *
 * Copyright (c) 2017 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 esextcTessellationShaderWinding.cpp
 * \brief Test winding order with tessellation shaders
 */ /*-------------------------------------------------------------------*/

#include "esextcTessellationShaderWinding.hpp"
#include "deSharedPtr.hpp"
#include "esextcTessellationShaderUtils.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "gluPixelTransfer.hpp"
#include "gluShaderProgram.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuRGBA.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"
#include <string>

namespace glcts
{

class WindingCase : public TestCaseBase
{
public:
	WindingCase(glcts::Context& context, const ExtParameters& extParams, std::string name, std::string primitiveType,
				std::string winding);

	void		  init(void);
	void		  deinit(void);
	IterateResult iterate(void);
	void prepareFramebuffer();

private:
	static const int RENDER_SIZE = 64;

	de::SharedPtr<const glu::ShaderProgram> m_program;
	glw::GLuint m_rbo;
	glw::GLuint m_fbo;
};

WindingCase::WindingCase(glcts::Context& context, const ExtParameters& extParams, std::string name,
						 std::string primitiveType, std::string winding)
	: TestCaseBase(context, extParams, name.c_str(), "")
{
	DE_ASSERT((primitiveType.compare("triangles") == 0) || (primitiveType.compare("quads") == 0));
	DE_ASSERT((winding.compare("cw") == 0) || (winding.compare("ccw") == 0));

	m_specializationMap["PRIMITIVE_TYPE"] = primitiveType;
	m_specializationMap["WINDING"]        = winding;
	m_rbo                                 = 0;
	m_fbo                                 = 0;
}

void WindingCase::init(void)
{
	TestCaseBase::init();
	if (!m_is_tessellation_shader_supported)
	{
		TCU_THROW(NotSupportedError, TESSELLATION_SHADER_EXTENSION_NOT_SUPPORTED);
	}

	TestCaseBase::init();

	const char* vs("${VERSION}\n"
				   "void main (void)\n"
				   "{\n"
				   "}\n");
	const char* tcs("${VERSION}\n"
					"${TESSELLATION_SHADER_REQUIRE}\n"
					"layout (vertices = 1) out;\n"
					"void main (void)\n"
					"{\n"
					"	gl_TessLevelInner[0] = 5.0;\n"
					"	gl_TessLevelInner[1] = 5.0;\n"
					"\n"
					"	gl_TessLevelOuter[0] = 5.0;\n"
					"	gl_TessLevelOuter[1] = 5.0;\n"
					"	gl_TessLevelOuter[2] = 5.0;\n"
					"	gl_TessLevelOuter[3] = 5.0;\n"
					"}\n");
	const char* tes("${VERSION}\n"
					"${TESSELLATION_SHADER_REQUIRE}\n"
					"layout (${PRIMITIVE_TYPE}, ${WINDING}) in;\n"
					"void main (void)\n"
					"{\n"
					"	gl_Position = vec4(gl_TessCoord.xy*2.0 - 1.0, 0.0, 1.0);\n"
					"}\n");
	const char* fs("${VERSION}\n"
				   "layout (location = 0) out mediump vec4 o_color;\n"
				   "void main (void)\n"
				   "{\n"
				   "	o_color = vec4(1.0);\n"
				   "}\n");

	m_program = de::SharedPtr<const glu::ShaderProgram>(
		new glu::ShaderProgram(m_context.getRenderContext(),
							   glu::ProgramSources() << glu::VertexSource(specializeShader(1, &vs))
													 << glu::TessellationControlSource(specializeShader(1, &tcs))
													 << glu::TessellationEvaluationSource(specializeShader(1, &tes))
													 << glu::FragmentSource(specializeShader(1, &fs))));

	m_testCtx.getLog() << *m_program;
	if (!m_program->isOk())
		TCU_FAIL("Program compilation failed");
}

void WindingCase::deinit(void)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

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

	if (m_rbo)
	{
		gl.deleteRenderbuffers(1, &m_rbo);
		m_rbo = 0;
	}

	m_program.clear();
}

/** @brief Bind default framebuffer object.
 *
 *  @note The function may throw if unexpected error has occured.
 */
void WindingCase::prepareFramebuffer()
{
	/* Shortcut for GL functionality */
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	gl.genRenderbuffers(1, &m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenRenderbuffers call failed.");

	gl.bindRenderbuffer(GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindRenderbuffer call failed.");

	gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, RENDER_SIZE, RENDER_SIZE);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorage call failed.");

	gl.genFramebuffers(1, &m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers call failed.");

	gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer call failed.");

	gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_rbo);
	GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferRenderbuffer call failed.");
}

WindingCase::IterateResult WindingCase::iterate(void)
{
	const glu::RenderContext& renderCtx = m_context.getRenderContext();
	const deUint32			  programGL = m_program->getProgram();
	const glw::Functions&	 gl		= renderCtx.getFunctions();

	const unsigned int windingTaken[2]	 = { GL_CW, GL_CCW };
	const char*		   windingTakenName[2] = { "GL_CW", "GL_CCW" };

	const bool testPrimitiveTypeIsTriangles = (m_specializationMap["PRIMITIVE_TYPE"].compare("triangles") == 0);
	const bool testWindingIsCW				= (m_specializationMap["WINDING"].compare("cw") == 0);
	bool	   success						= true;

	prepareFramebuffer();
	gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
	gl.clearColor(1.0f, 0.0f, 0.0f, 1.0f);
	gl.useProgram(programGL);

	gl.patchParameteri(GL_PATCH_VERTICES, 1);

	gl.enable(GL_CULL_FACE);

	deUint32 vaoGL;
	gl.genVertexArrays(1, &vaoGL);
	gl.bindVertexArray(vaoGL);

	m_testCtx.getLog() << tcu::TestLog::Message << "Face culling enabled" << tcu::TestLog::EndMessage;

	for (int windingIndex = 0; windingIndex < 2; windingIndex++)
	{
		m_testCtx.getLog() << tcu::TestLog::Message << "Setting glFrontFace(" << windingTakenName[windingIndex] << ")"
						   << tcu::TestLog::EndMessage;

		gl.frontFace(windingTaken[windingIndex]);

		gl.clear(GL_COLOR_BUFFER_BIT);
		gl.drawArrays(GL_PATCHES, 0, 1);
		GLU_EXPECT_NO_ERROR(gl.getError(), "Draw failed");

		{
			tcu::Surface rendered(RENDER_SIZE, RENDER_SIZE);
			glu::readPixels(renderCtx, 0, 0, rendered.getAccess());
			m_testCtx.getLog() << tcu::TestLog::Image("RenderedImage", "Rendered Image", rendered);

			{
				const int badPixelTolerance =
					testPrimitiveTypeIsTriangles ? 5 * de::max(rendered.getWidth(), rendered.getHeight()) : 0;
				const int totalNumPixels = rendered.getWidth() * rendered.getHeight();

				int numWhitePixels = 0;
				int numRedPixels   = 0;
				for (int y = 0; y < rendered.getHeight(); y++)
					for (int x = 0; x < rendered.getWidth(); x++)
					{
						numWhitePixels += rendered.getPixel(x, y) == tcu::RGBA::white() ? 1 : 0;
						numRedPixels += rendered.getPixel(x, y) == tcu::RGBA::red() ? 1 : 0;
					}

				DE_ASSERT(numWhitePixels + numRedPixels <= totalNumPixels);

				m_testCtx.getLog() << tcu::TestLog::Message << "Note: got " << numWhitePixels << " white and "
								   << numRedPixels << " red pixels" << tcu::TestLog::EndMessage;

				if (totalNumPixels - numWhitePixels - numRedPixels > badPixelTolerance)
				{
					m_testCtx.getLog() << tcu::TestLog::Message << "Failure: Got "
									   << totalNumPixels - numWhitePixels - numRedPixels
									   << " other than white or red pixels (maximum tolerance " << badPixelTolerance
									   << ")" << tcu::TestLog::EndMessage;
					success = false;
					break;
				}

				bool frontFaceWindingIsCW = (windingIndex == 0);
				if (frontFaceWindingIsCW == testWindingIsCW)
				{
					if (testPrimitiveTypeIsTriangles)
					{
						if (de::abs(numWhitePixels - totalNumPixels / 2) > badPixelTolerance)
						{
							m_testCtx.getLog() << tcu::TestLog::Message
											   << "Failure: wrong number of white pixels; expected approximately "
											   << totalNumPixels / 2 << tcu::TestLog::EndMessage;
							success = false;
							break;
						}
					}
					else // test primitive type is quads
					{
						if (numWhitePixels != totalNumPixels)
						{
							m_testCtx.getLog()
								<< tcu::TestLog::Message << "Failure: expected only white pixels (full-viewport quad)"
								<< tcu::TestLog::EndMessage;
							success = false;
							break;
						}
					}
				}
				else
				{
					if (numWhitePixels != 0)
					{
						m_testCtx.getLog()
							<< tcu::TestLog::Message << "Failure: expected only red pixels (everything culled)"
							<< tcu::TestLog::EndMessage;
						success = false;
						break;
					}
				}
			}
		}
	}

	gl.bindVertexArray(0);
	gl.deleteVertexArrays(1, &vaoGL);

	m_testCtx.setTestResult(success ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
							success ? "Pass" : "Image verification failed");
	return STOP;
}

/** Constructor
 *
 * @param context Test context
 **/
TesselationShaderWindingTests::TesselationShaderWindingTests(glcts::Context& context, const ExtParameters& extParams)
	: TestCaseGroupBase(context, extParams, "winding", "Verifies winding order with tessellation shaders")
{
}

/**
 * Initializes test groups for winding tests
 **/
void TesselationShaderWindingTests::init(void)
{
	addChild(new WindingCase(m_context, m_extParams, "triangles_ccw", "triangles", "ccw"));
	addChild(new WindingCase(m_context, m_extParams, "triangles_cw", "triangles", "cw"));
	addChild(new WindingCase(m_context, m_extParams, "quads_ccw", "quads", "ccw"));
	addChild(new WindingCase(m_context, m_extParams, "quads_cw", "quads", "cw"));
}

} /* namespace glcts */