xref: /third_party/vk-gl-cts/external/openglcts/modules/glesext/geometry_shader/esextcGeometryShaderBlitting.cpp

/*-------------------------------------------------------------------------
 * 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 "esextcGeometryShaderBlitting.hpp"
#include "gluContextInfo.hpp"
#include "gluDefs.hpp"
#include "glwEnums.hpp"
#include "glwFunctions.hpp"
#include "tcuTestLog.hpp"
#include <cstring>

/* 3d texture layers count */
#define TEXTURE_DEPTH (4)
/* 3d texture width */
#define TEXTURE_WIDTH (4)
/* 3d texture height */
#define TEXTURE_HEIGHT (4)
/* texture texel components */
#define TEXTURE_TEXEL_COMPONENTS (4)

namespace glcts
{
/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's desricption
 **/
GeometryShaderBlitting::GeometryShaderBlitting(Context& context, const ExtParameters& extParams, const char* name,
											   const char* description)
	: TestCaseBase(context, extParams, name, description)
	, m_draw_fbo_completeness(GL_NONE)
	, m_read_fbo_completeness(GL_NONE)
	, m_fbo_draw_id(0)
	, m_fbo_read_id(0)
	, m_to_draw(0)
	, m_to_read(0)
	, m_vao_id(0)
{
	/* Left blank on purpose */
}

/** 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 GeometryShaderBlitting::iterate(void)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

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

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

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

	/* Generate texture objects */
	gl.genTextures(1, &m_to_draw);
	gl.genTextures(1, &m_to_read);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error generating texture objects");

	/* Generate framebuffer objects */
	gl.genFramebuffers(1, &m_fbo_draw_id);
	gl.genFramebuffers(1, &m_fbo_read_id);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting up framebuffer objects");

	/* Configure texture storage */
	gl.bindTexture(GL_TEXTURE_3D, m_to_draw);
	gl.texImage3D(GL_TEXTURE_3D, 0 /* level */, GL_RGBA8, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, 0 /* border */,
				  GL_RGBA, GL_UNSIGNED_BYTE, NULL);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting up texture objects");

	gl.bindTexture(GL_TEXTURE_3D, m_to_read);
	gl.texImage3D(GL_TEXTURE_3D, 0 /* level */, GL_RGBA8, TEXTURE_WIDTH, TEXTURE_HEIGHT, TEXTURE_DEPTH, 0 /* border */,
				  GL_RGBA, GL_UNSIGNED_BYTE, NULL);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting up texture objects");

	unsigned char layer_source1[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS];
	unsigned char layer_source2[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS];
	unsigned char layer_source3[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS];
	unsigned char layer_source4[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS];
	unsigned char layer_target[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS];
	unsigned char result_data[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS];

	memset(layer_source1, 0, sizeof(layer_source1));
	memset(layer_source2, 0, sizeof(layer_source2));
	memset(layer_source3, 0, sizeof(layer_source3));
	memset(layer_source4, 0, sizeof(layer_source4));
	memset(layer_target, 0, sizeof(layer_target));

	for (unsigned int n = 0; n < TEXTURE_WIDTH * TEXTURE_HEIGHT; ++n)
	{
		layer_source1[n * TEXTURE_TEXEL_COMPONENTS + 0] = 255;
		layer_source2[n * TEXTURE_TEXEL_COMPONENTS + 1] = 255;
		layer_source3[n * TEXTURE_TEXEL_COMPONENTS + 2] = 255;
		layer_source4[n * TEXTURE_TEXEL_COMPONENTS + 3] = 255;
	} /* for (all pixels) */

	/* Set up draw FBO */
	setUpFramebuffersForRendering(m_fbo_draw_id, m_fbo_read_id, m_to_draw, m_to_read);

	/* Fill texture objects with data */
	gl.bindTexture(GL_TEXTURE_3D, m_to_read);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 0 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_source1);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 1 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_source2);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 2 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_source3);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 3 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_source4);

	gl.bindTexture(GL_TEXTURE_3D, m_to_draw);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 0 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_target);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 1 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_target);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 2 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_target);
	gl.texSubImage3D(GL_TEXTURE_3D, 0 /* level */, 0 /* xoffset */, 0 /* yoffset */, 3 /* layer */, TEXTURE_WIDTH,
					 TEXTURE_HEIGHT, 1 /* depth */, GL_RGBA, GL_UNSIGNED_BYTE, layer_target);

	/* Check FB completeness */
	m_draw_fbo_completeness = gl.checkFramebufferStatus(GL_DRAW_FRAMEBUFFER);
	m_read_fbo_completeness = gl.checkFramebufferStatus(GL_READ_FRAMEBUFFER);

	if (m_draw_fbo_completeness != GL_FRAMEBUFFER_COMPLETE)
	{
		TCU_FAIL("Draw framebuffer is reported as incomplete, though expected it to be complete");
	}

	if (m_read_fbo_completeness != GL_FRAMEBUFFER_COMPLETE)
	{
		TCU_FAIL("Read framebuffer is reported as incomplete, though expected it to be complete");
	}

	/* Blit! */
	gl.blitFramebuffer(0 /* srcX0 */, 0 /* srcY0 */, TEXTURE_WIDTH, TEXTURE_HEIGHT, 0 /* dstX0 */, 0 /* dstY0 */,
					   TEXTURE_WIDTH, TEXTURE_HEIGHT, GL_COLOR_BUFFER_BIT, GL_NEAREST);

	GLU_EXPECT_NO_ERROR(gl.getError(), "Error blitting");

	for (unsigned int n = 0; n < TEXTURE_DEPTH /* layers */; ++n)
	{
		unsigned char expected_result_data[TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS];
		memset(expected_result_data, 0, sizeof(expected_result_data));

		if (n == 0)
		{
			memcpy(expected_result_data, layer_source1, sizeof(expected_result_data));
		}

		/* Set up read FBO */
		gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_draw_id);

		gl.framebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_to_draw, 0, n);
		GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting up FBOs setUpFramebuffersForReading");

		/* Read the rendered data */
		gl.readPixels(0 /* x */, 0 /* y */, TEXTURE_WIDTH, TEXTURE_HEIGHT, GL_RGBA, GL_UNSIGNED_BYTE, result_data);

		GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to read rendered pixel data");

		/* Compare the rendered data with reference data */
		for (unsigned int index = 0; index < TEXTURE_WIDTH * TEXTURE_HEIGHT * TEXTURE_TEXEL_COMPONENTS;
			 index += TEXTURE_TEXEL_COMPONENTS)
		{
			if (memcmp(&expected_result_data[index], &result_data[index], TEXTURE_TEXEL_COMPONENTS) != 0)
			{
				m_testCtx.getLog() << tcu::TestLog::Message << "Rendered data [" << (int)result_data[index + 0] << ", "
								   << (int)result_data[index + 1] << ", " << (int)result_data[index + 2] << ", "
								   << (int)result_data[index + 3] << "] is different from reference data ["
								   << (int)expected_result_data[index + 0] << ", "
								   << (int)expected_result_data[index + 1] << ", "
								   << (int)expected_result_data[index + 2] << ", "
								   << (int)expected_result_data[index + 3] << "] !" << tcu::TestLog::EndMessage;

				m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
				return STOP;
			}
		} /* for (each index) */
	}	 /* for (all layers) */

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

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

	/* Reset OpenGL ES state */
	gl.bindTexture(GL_TEXTURE_3D, 0);
	gl.bindVertexArray(0);
	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, 0);
	gl.bindFramebuffer(GL_READ_FRAMEBUFFER, 0);

	/* Clean up */
	if (m_fbo_draw_id != 0)
	{
		gl.deleteFramebuffers(1, &m_fbo_draw_id);
	}

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

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

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

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

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

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's desricption
 **/
GeometryShaderBlittingLayeredToNonLayered::GeometryShaderBlittingLayeredToNonLayered(Context&			  context,
																					 const ExtParameters& extParams,
																					 const char*		  name,
																					 const char*		  description)
	: GeometryShaderBlitting(context, extParams, name, description)
{
	/* Left blank on purpose */
}

/** Setup framebuffers for rendering
 *
 */
void GeometryShaderBlittingLayeredToNonLayered::setUpFramebuffersForRendering(glw::GLuint fbo_draw_id,
																			  glw::GLuint fbo_read_id,
																			  glw::GLint to_draw, glw::GLint to_read)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Bind framebuffers */
	gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo_read_id);
	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_draw_id);

	/* Blitting from a layered read framebuffer to a non-layered draw framebuffer*/
	gl.framebufferTexture(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, to_read, 0 /* level */);
	gl.framebufferTextureLayer(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, to_draw, 0, 0);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting up FBOs setUpFramebuffersForRendering");
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's desricption
 **/
GeometryShaderBlittingNonLayeredToLayered::GeometryShaderBlittingNonLayeredToLayered(Context&			  context,
																					 const ExtParameters& extParams,
																					 const char*		  name,
																					 const char*		  description)
	: GeometryShaderBlitting(context, extParams, name, description)
{
	/* Left blank on purpose */
}

/** Setup framebuffers for rendering
 *
 */
void GeometryShaderBlittingNonLayeredToLayered::setUpFramebuffersForRendering(glw::GLuint fbo_draw_id,
																			  glw::GLuint fbo_read_id,
																			  glw::GLint to_draw, glw::GLint to_read)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Bind framebuffers */
	gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo_read_id);
	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_draw_id);

	/*  Blitting from a non-layered read framebuffer to a layered draw framebuffer */
	gl.framebufferTextureLayer(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, to_read, 0, 0);
	gl.framebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, to_draw, 0 /* level */);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting up FBOs setUpFramebuffersForRendering");
}

/** Constructor
 *
 * @param context       Test context
 * @param name          Test case's name
 * @param description   Test case's desricption
 **/
GeometryShaderBlittingLayeredToLayered::GeometryShaderBlittingLayeredToLayered(Context&				context,
																			   const ExtParameters& extParams,
																			   const char*			name,
																			   const char*			description)
	: GeometryShaderBlitting(context, extParams, name, description)
{
	/* Left blank on purpose */
}

/** Setup framebuffers for rendering
 *
 */
void GeometryShaderBlittingLayeredToLayered::setUpFramebuffersForRendering(glw::GLuint fbo_draw_id,
																		   glw::GLuint fbo_read_id, glw::GLint to_draw,
																		   glw::GLint to_read)
{
	const glw::Functions& gl = m_context.getRenderContext().getFunctions();

	/* Bind framebuffers */
	gl.bindFramebuffer(GL_READ_FRAMEBUFFER, fbo_read_id);
	gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, fbo_draw_id);

	/* Blitting from a layered read framebuffer to a layered draw framebuffer */
	gl.framebufferTexture(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, to_read, 0 /* level */);
	gl.framebufferTexture(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, to_draw, 0 /* level */);
	GLU_EXPECT_NO_ERROR(gl.getError(), "Error setting up FBOs setUpFramebuffersForRendering");
}

} // namespace glcts