blob: f8855112f164d7c649018a1ddb02b3c98a10e391 [file] [log] [blame]
/*-------------------------------------------------------------------------
* 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 esextcTextureCubeMapArrayETC2Support.cpp
* \brief texture_cube_map_array ETC2 support (Test 10)
*/ /*-------------------------------------------------------------------*/
#include "esextcTextureCubeMapArrayETC2Support.hpp"
#include "glcTestCase.hpp"
#include "gluDefs.hpp"
#include "gluPixelTransfer.hpp"
#include "glwEnums.inl"
#include "glwTypes.inl"
#include "tcuImageCompare.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuSurface.hpp"
#include "tcuTestLog.hpp"
namespace glcts
{
enum TextureSize
{
RENDER_WIDTH = 8,
RENDER_HEIGHT = 8
};
/** Constructor
*
* @param context Test context
* @param name Test case's name
* @param description Test case's description
**/
TextureCubeMapArrayETC2Support::TextureCubeMapArrayETC2Support(Context &context, const ExtParameters &extParams,
const char *name, const char *description)
: TestCaseBase(context, extParams, name, description)
, m_fbo(0)
, m_rbo(0)
, m_vao(0)
, m_texture(0)
, m_program(0)
{
}
/** Deinitializes test
*
**/
void TextureCubeMapArrayETC2Support::deinit(void)
{
glcts::TestCaseBase::deinit();
}
/** @brief Iterate Functional Test cases.
*
* @return Iteration result.
*/
tcu::TestCase::IterateResult TextureCubeMapArrayETC2Support::iterate(void)
{
prepareFramebuffer();
prepareProgram();
prepareVertexArrayObject();
prepareTexture();
draw();
if (isRenderedImageValid())
m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
else
m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
clean();
return STOP;
}
/** @brief Bind default framebuffer object.
*
* @note The function may throw if unexpected error has occured.
*/
void TextureCubeMapArrayETC2Support::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_WIDTH, RENDER_HEIGHT);
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.");
}
/** @brief Function generate and bind empty vertex array object.
*
* @note The function may throw if unexpected error has occured.
*/
void TextureCubeMapArrayETC2Support::prepareVertexArrayObject()
{
/* Shortcut for GL functionality */
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.genVertexArrays(1, &m_vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays call failed.");
gl.bindVertexArray(m_vao);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray call failed.");
}
/** @brief Function builds test's GLSL program.
* If succeded, the program will be set to be used.
*
* @note The function may throw if unexpected error has occured.
*/
void TextureCubeMapArrayETC2Support::prepareProgram()
{
/* Shortcut for GL functionality */
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
struct Shader
{
glw::GLchar const *const source;
glw::GLenum const type;
glw::GLuint id;
} shader[] = {{s_vertex_shader, GL_VERTEX_SHADER, 0}, {s_fragment_shader, GL_FRAGMENT_SHADER, 0}};
bool programPreparationFailed = false;
glw::GLuint const shader_count = sizeof(shader) / sizeof(shader[0]);
/* Create program. */
m_program = gl.createProgram();
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram call failed.");
/* Shader compilation. */
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (DE_NULL != shader[i].source)
{
shader[i].id = gl.createShader(shader[i].type);
GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader call failed.");
gl.attachShader(m_program, shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader call failed.");
glu::ContextType contextType = m_context.getRenderContext().getType();
glu::GLSLVersion glslVersion = glu::getContextTypeGLSLVersion(contextType);
std::string shaderSource(glu::getGLSLVersionDeclaration(glslVersion));
shaderSource += shader[i].source;
const char *source = shaderSource.c_str();
gl.shaderSource(shader[i].id, 1, &source, NULL);
GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource call failed.");
gl.compileShader(shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader call failed.");
glw::GLint status = GL_FALSE;
gl.getShaderiv(shader[i].id, GL_COMPILE_STATUS, &status);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");
if (GL_FALSE == status)
{
glw::GLint log_size = 0;
gl.getShaderiv(shader[i].id, GL_INFO_LOG_LENGTH, &log_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv call failed.");
glw::GLchar *log_text = new glw::GLchar[log_size];
gl.getShaderInfoLog(shader[i].id, log_size, NULL, &log_text[0]);
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Shader compilation error, log:\n"
<< log_text << "\n"
<< "Shader source code:\n"
<< shaderSource << "\n"
<< tcu::TestLog::EndMessage;
delete[] log_text;
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog call failed.");
programPreparationFailed = true;
break;
}
}
}
if (programPreparationFailed)
{
if (m_program)
{
gl.deleteProgram(m_program);
m_program = 0;
}
}
else
{
/* Link. */
gl.linkProgram(m_program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glLlinkProgram call failed.");
glw::GLint status = GL_FALSE;
gl.getProgramiv(m_program, GL_LINK_STATUS, &status);
if (GL_TRUE == status)
{
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (shader[i].id)
{
gl.detachShader(m_program, shader[i].id);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDetachShader call failed.");
}
}
}
else
{
glw::GLint log_size = 0;
gl.getProgramiv(m_program, GL_INFO_LOG_LENGTH, &log_size);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv call failed.");
glw::GLchar *log_text = new glw::GLchar[log_size];
gl.getProgramInfoLog(m_program, log_size, NULL, &log_text[0]);
m_context.getTestContext().getLog() << tcu::TestLog::Message << "Program linkage has failed due to:\n"
<< log_text << "\n"
<< tcu::TestLog::EndMessage;
delete[] log_text;
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog call failed.");
programPreparationFailed = true;
}
}
for (glw::GLuint i = 0; i < shader_count; ++i)
{
if (0 != shader[i].id)
{
gl.deleteShader(shader[i].id);
shader[i].id = 0;
}
}
if (m_program)
{
glw::GLint textureSampler = gl.getUniformLocation(m_program, "texture_sampler");
GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation call failed.");
gl.useProgram(m_program);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram call failed.");
gl.uniform1i(textureSampler, 0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i call failed.");
}
else
TCU_FAIL("Failed to prepare program");
}
/** @brief Function prepares texture object with test's data.
*
* @note The function may throw if unexpected error has occured.
*/
void TextureCubeMapArrayETC2Support::prepareTexture()
{
/* Shortcut for GL functionality */
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.activeTexture(GL_TEXTURE0);
GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture call failed.");
/* Texture creation and binding. */
gl.genTextures(1, &m_texture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures call failed.");
const glw::GLuint target = GL_TEXTURE_CUBE_MAP_ARRAY;
gl.bindTexture(target, m_texture);
GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture call failed.");
/* Uploading texture. */
gl.compressedTexImage3D(target, 0, GL_COMPRESSED_RGB8_ETC2, RENDER_WIDTH, RENDER_HEIGHT, 6, 0,
s_compressed_RGB_texture_data_size, s_compressed_RGB_texture_data);
GLU_EXPECT_NO_ERROR(gl.getError(), "glCompressedTexImage3D call failed.");
gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
gl.texParameteri(target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
gl.texParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
gl.texParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri call failed.");
}
/** @brief Function draws a quad.
*
* @note The function may throw if unexpected error has occured.
*/
void TextureCubeMapArrayETC2Support::draw()
{
/* Shortcut for GL functionality. */
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
gl.viewport(0, 0, RENDER_WIDTH, RENDER_HEIGHT);
gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4);
GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays call failed.");
}
/** @brief Check if drawn image is same as reference.
*/
bool TextureCubeMapArrayETC2Support::isRenderedImageValid()
{
const glw::Functions &gl = m_context.getRenderContext().getFunctions();
/* Construct reference image. */
const tcu::TextureFormat textureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8);
tcu::ConstPixelBufferAccess referenceImg(textureFormat, RENDER_WIDTH, RENDER_HEIGHT, 1, s_RGB_texture_data);
/* Read GL image. */
GLubyte empty_data[RENDER_WIDTH * RENDER_HEIGHT * 4];
tcu::PixelBufferAccess renderedImg(textureFormat, RENDER_WIDTH, RENDER_HEIGHT, 1, empty_data);
glu::readPixels(m_context.getRenderContext(), 0, 0, renderedImg);
GLU_EXPECT_NO_ERROR(gl.getError(), "glu::readPixels call failed.");
/* Compare images using a big thresholdbecause as compression brings inaccuracy. */
const float compareThreshold = 0.05f;
return tcu::fuzzyCompare(m_testCtx.getLog(), "CompareResult", "Image Comparison Result", referenceImg, renderedImg,
compareThreshold, tcu::COMPARE_LOG_RESULT);
}
/** @brief Release all GL objects.
*/
void TextureCubeMapArrayETC2Support::clean()
{
/* Shortcut for GL functionality. */
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;
}
if (m_vao)
{
gl.deleteVertexArrays(1, &m_vao);
m_vao = 0;
}
if (m_texture)
{
gl.deleteTextures(1, &m_texture);
m_texture = 0;
}
if (m_program)
{
gl.useProgram(0);
gl.deleteProgram(m_program);
m_program = 0;
}
}
/* Vertex shader source code. */
const glw::GLchar TextureCubeMapArrayETC2Support::s_vertex_shader[] =
"\n"
"out highp vec4 texCoord;\n"
"void main()\n"
"{\n"
" switch(gl_VertexID)\n"
" {\n"
" case 0:\n"
" gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
" break;\n"
" case 1:\n"
" gl_Position = vec4( 1.0, 1.0, 0.0, 1.0);\n"
" break;\n"
" case 2:\n"
" gl_Position = vec4(-1.0,-1.0, 0.0, 1.0);\n"
" break;\n"
" case 3:\n"
" gl_Position = vec4( 1.0,-1.0, 0.0, 1.0);\n"
" break;\n"
" }\n"
" texCoord = vec4(gl_Position.xy, 1.0, 0.0);"
"}\n";
/* Fragment shader source program. */
const glw::GLchar TextureCubeMapArrayETC2Support::s_fragment_shader[] =
"\n"
"uniform highp samplerCubeArray texture_sampler;\n"
"in highp vec4 texCoord;"
"out highp vec4 color;\n"
"void main()\n"
"{\n"
" color = texture(texture_sampler, texCoord);\n"
"}\n";
/* Texture data, 8x8 RGBA. */
const glw::GLubyte TextureCubeMapArrayETC2Support::s_RGB_texture_data[] = {
0, 224, 0, 255, 0, 224, 32, 255, 0, 224, 64, 255, 0, 224, 96, 255, 0, 224, 128, 255, 0, 224,
160, 255, 0, 224, 192, 255, 0, 224, 224, 255, 0, 192, 0, 255, 0, 192, 32, 255, 0, 192, 64, 255,
0, 192, 96, 255, 0, 192, 128, 255, 0, 192, 160, 255, 0, 192, 192, 255, 0, 192, 224, 255,
0, 160, 0, 255, 0, 160, 32, 255, 0, 160, 64, 255, 0, 160, 96, 255, 0, 160, 128, 255, 0, 160,
160, 255, 0, 160, 192, 255, 0, 160, 224, 255, 0, 128, 0, 255, 0, 128, 32, 255, 0, 128, 64, 255,
0, 128, 96, 255, 0, 128, 128, 255, 0, 128, 160, 255, 0, 128, 192, 255, 0, 128, 224, 255,
0, 96, 0, 255, 0, 96, 32, 255, 0, 96, 64, 255, 0, 96, 96, 255, 0, 96, 128, 255, 0, 96,
160, 255, 0, 96, 192, 255, 0, 96, 224, 255, 0, 64, 0, 255, 0, 64, 32, 255, 0, 64, 64, 255,
0, 64, 96, 255, 0, 64, 128, 255, 0, 64, 160, 255, 0, 64, 192, 255, 0, 64, 224, 255,
0, 32, 0, 255, 0, 32, 32, 255, 0, 32, 64, 255, 0, 32, 96, 255, 0, 32, 128, 255, 0, 32,
160, 255, 0, 32, 192, 255, 0, 32, 224, 255, 0, 0, 0, 255, 0, 0, 32, 255, 0, 0, 64, 255,
0, 0, 96, 255, 0, 0, 128, 255, 0, 0, 160, 255, 0, 0, 192, 255, 0, 0, 224, 255,
};
const glw::GLsizei TextureCubeMapArrayETC2Support::s_RGB_texture_data_size =
sizeof(TextureCubeMapArrayETC2Support::s_RGB_texture_data);
/* Compressed texture data 8x8x6 RGB - all layers are the same. */
const glw::GLubyte TextureCubeMapArrayETC2Support::s_compressed_RGB_texture_data[] = {
/* Layer 0 */
0x0,
0x0,
0x4,
0x2,
0x1,
0x0,
0x6f,
0xc0,
0x0,
0x1,
0x4,
0x2,
0x1,
0xf8,
0x6f,
0xe0,
0x1,
0x0,
0x4,
0x2,
0x80,
0xf8,
0x5f,
0xc0,
0x1,
0x0,
0xfb,
0x82,
0x81,
0xf8,
0x5f,
0xe0,
/* Layer 1 */
0x0,
0x0,
0x4,
0x2,
0x1,
0x0,
0x6f,
0xc0,
0x0,
0x1,
0x4,
0x2,
0x1,
0xf8,
0x6f,
0xe0,
0x1,
0x0,
0x4,
0x2,
0x80,
0xf8,
0x5f,
0xc0,
0x1,
0x0,
0xfb,
0x82,
0x81,
0xf8,
0x5f,
0xe0,
/* Layer 2 */
0x0,
0x0,
0x4,
0x2,
0x1,
0x0,
0x6f,
0xc0,
0x0,
0x1,
0x4,
0x2,
0x1,
0xf8,
0x6f,
0xe0,
0x1,
0x0,
0x4,
0x2,
0x80,
0xf8,
0x5f,
0xc0,
0x1,
0x0,
0xfb,
0x82,
0x81,
0xf8,
0x5f,
0xe0,
/* Layer 3 */
0x0,
0x0,
0x4,
0x2,
0x1,
0x0,
0x6f,
0xc0,
0x0,
0x1,
0x4,
0x2,
0x1,
0xf8,
0x6f,
0xe0,
0x1,
0x0,
0x4,
0x2,
0x80,
0xf8,
0x5f,
0xc0,
0x1,
0x0,
0xfb,
0x82,
0x81,
0xf8,
0x5f,
0xe0,
/* Layer 4 */
0x0,
0x0,
0x4,
0x2,
0x1,
0x0,
0x6f,
0xc0,
0x0,
0x1,
0x4,
0x2,
0x1,
0xf8,
0x6f,
0xe0,
0x1,
0x0,
0x4,
0x2,
0x80,
0xf8,
0x5f,
0xc0,
0x1,
0x0,
0xfb,
0x82,
0x81,
0xf8,
0x5f,
0xe0,
/* Layer 5 */
0x0,
0x0,
0x4,
0x2,
0x1,
0x0,
0x6f,
0xc0,
0x0,
0x1,
0x4,
0x2,
0x1,
0xf8,
0x6f,
0xe0,
0x1,
0x0,
0x4,
0x2,
0x80,
0xf8,
0x5f,
0xc0,
0x1,
0x0,
0xfb,
0x82,
0x81,
0xf8,
0x5f,
0xe0,
};
/* Compressed texture width. */
const glw::GLsizei TextureCubeMapArrayETC2Support::s_compressed_RGB_texture_data_size =
sizeof(TextureCubeMapArrayETC2Support::s_compressed_RGB_texture_data);
} // namespace glcts