/** Verify rendered polygon anisotropy. * * @param gl OpenGL functions wrapper * * @return Returns points value. Less points means better anisotropy (smoother strips). */ GLuint TextureFilterAnisotropicDrawingTestCase::verifyScene(const glw::Functions& gl) { std::vector<GLubyte> pixels; pixels.resize(32 * 8 * 4); gl.readPixels(0, 23, 32, 8, GL_RGBA, GL_UNSIGNED_BYTE, pixels.data()); GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels"); GLuint sum = 0; GLubyte last = 0; GLubyte current = 0; for (int j = 0; j < 8; ++j) { for (int i = 0; i < 32; ++i) { current = pixels[(i + j * 32) * 4]; if (i > 0) sum += deAbs32((int)current - (int)last); last = current; } } return sum; }
/** Release texture. * * @param gl OpenGL functions wrapper */ void TextureFilterAnisotropicDrawingTestCase::releaseTexture(const glw::Functions& gl) { if (m_texture) gl.deleteTextures(1, &m_texture); m_texture = 0; }
static std::vector<int> querySampleCounts (const glw::Functions& gl, deUint32 format) { int numSampleCounts = 0; std::vector<int> sampleCounts; gl.getInternalformativ(GL_RENDERBUFFER, format, GL_NUM_SAMPLE_COUNTS, 1, &numSampleCounts); if (numSampleCounts > 0) { sampleCounts.resize(numSampleCounts); gl.getInternalformativ(GL_RENDERBUFFER, format, GL_SAMPLES, (glw::GLsizei)sampleCounts.size(), &sampleCounts[0]); } GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to query sample counts for format"); return sampleCounts; }
static std::vector<std::string> getExtensions (const glw::Functions& gl, ApiType apiType) { using std::vector; using std::string; if (apiType.getProfile() == PROFILE_ES && apiType.getMajorVersion() == 2) { TCU_CHECK(gl.getString); const char* extStr = (const char*)gl.getString(GL_EXTENSIONS); GLU_EXPECT_NO_ERROR(gl.getError(), "glGetString(GL_EXTENSIONS)"); if (extStr) return de::splitString(extStr); else throw tcu::TestError("glGetString(GL_EXTENSIONS) returned null pointer", DE_NULL, __FILE__, __LINE__); } else { int numExtensions = 0; vector<string> extensions; TCU_CHECK(gl.getIntegerv && gl.getStringi); gl.getIntegerv(GL_NUM_EXTENSIONS, &numExtensions); GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_NUM_EXTENSIONS)"); if (numExtensions > 0) { extensions.resize(numExtensions); for (int ndx = 0; ndx < numExtensions; ndx++) { const char* const ext = (const char*)gl.getStringi(GL_EXTENSIONS, ndx); GLU_EXPECT_NO_ERROR(gl.getError(), "glGetStringi(GL_EXTENSIONS)"); if (ext) extensions[ndx] = ext; else throw tcu::TestError("glGetStringi(GL_EXTENSIONS) returned null pointer", DE_NULL, __FILE__, __LINE__); } } return extensions; } }
/** Verify if get* queries for GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT pname works as expected. * * @param gl OpenGL functions wrapper * * @return Returns true if queries test passed, false otherwise. */ bool TextureFilterAnisotropicQueriesTestCase::verifyGet(const glw::Functions& gl) { GLboolean bValue; GLint iValue; GLfloat fValue; GLdouble dValue; gl.getBooleanv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &bValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getBooleanv"); gl.getIntegerv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &iValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getIntegerv"); gl.getFloatv(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &fValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getFloatv"); if (glu::isContextTypeGLCore(m_context.getRenderContext().getType())) { gl.getDoublev(GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT, &dValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getDoublev"); } return true; }
/** Render polygon with anisotropic filtering. * * @param gl OpenGL functions wrapper * @param target Texture target * @param anisoDegree Degree of anisotropy * * @return Returns true if no error occured, false otherwise. */ bool TextureFilterAnisotropicDrawingTestCase::drawTexture(const glw::Functions& gl, GLenum target, GLfloat anisoDegree) { const GLfloat vertices2[] = { -1.0f, 0.0f, -0.5f, 0.0f, 0.0f, -4.0f, 4.0f, -2.0f, 0.0f, 1.0f, 1.0f, 0.0f, -0.5f, 1.0f, 0.0f, -2.0f, 4.0f, -2.0f, 1.0f, 1.0f }; const GLfloat vertices3[] = { -1.0f, 0.0f, -0.5f, 0.0f, 0.0f, 0.0f, -4.0f, 4.0f, -2.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, -0.5f, 1.0f, 0.0f, 0.0f, -2.0f, 4.0f, -2.0f, 1.0f, 1.0f, 0.0f }; // Projection values. const GLfloat projectionMatrix[] = { 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, 0.5f, 0.0f, 0.0f, 0.0f, 0.0f, -2.5f / 1.5f, -2.0f / 1.5f, 0.0f, 0.0f, -1.0f, 0.0f }; gl.viewport(0, 0, 32, 32); std::string vertexShader = m_vertex; std::string fragmentShader = m_fragment; std::string texCoordType; std::string samplerType; TextureFilterAnisotropicUtils::generateTokens(target, texCoordType, samplerType); TextureFilterAnisotropicUtils::replaceToken("<TEXCOORD_TYPE>", texCoordType.c_str(), vertexShader); TextureFilterAnisotropicUtils::replaceToken("<TEXCOORD_TYPE>", texCoordType.c_str(), fragmentShader); TextureFilterAnisotropicUtils::replaceToken("<SAMPLER_TYPE>", samplerType.c_str(), vertexShader); TextureFilterAnisotropicUtils::replaceToken("<SAMPLER_TYPE>", samplerType.c_str(), fragmentShader); if (glu::isContextTypeGLCore(m_context.getRenderContext().getType())) { TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "130", vertexShader); TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "130", fragmentShader); } else { TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "300 es", vertexShader); TextureFilterAnisotropicUtils::replaceToken("<VERSION>", "300 es", fragmentShader); } ProgramSources sources = makeVtxFragSources(vertexShader, fragmentShader); ShaderProgram program(gl, sources); if (!program.isOk()) { m_testCtx.getLog() << tcu::TestLog::Message << "Shader build failed.\n" << "Vertex: " << program.getShaderInfo(SHADERTYPE_VERTEX).infoLog << "\n" << vertexShader << "\n" << "Fragment: " << program.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n" << fragmentShader << "\n" << "Program: " << program.getProgramInfo().infoLog << tcu::TestLog::EndMessage; return false; } GLuint vao; gl.genVertexArrays(1, &vao); GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays"); gl.bindVertexArray(vao); GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray"); GLuint vbo; gl.genBuffers(1, &vbo); GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers"); gl.bindBuffer(GL_ARRAY_BUFFER, vbo); GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer"); std::vector<GLfloat> vboData; vboData.resize(24); GLuint texCoordDim; if (texCoordType == "vec2") { texCoordDim = 2; deMemcpy((void*)vboData.data(), (void*)vertices2, sizeof(vertices2)); } else { texCoordDim = 3; deMemcpy((void*)vboData.data(), (void*)vertices3, sizeof(vertices3)); } gl.bufferData(GL_ARRAY_BUFFER, vboData.size() * sizeof(GLfloat), (GLvoid*)vboData.data(), GL_DYNAMIC_DRAW); GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData"); gl.useProgram(program.getProgram()); GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram"); GLuint matrixLocation = gl.getUniformLocation(program.getProgram(), "projectionMatrix"); GLuint texLocation = gl.getUniformLocation(program.getProgram(), "tex"); gl.activeTexture(GL_TEXTURE0); GLU_EXPECT_NO_ERROR(gl.getError(), "glActiveTexture"); gl.bindTexture(target, m_texture); GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture"); gl.uniformMatrix4fv(matrixLocation, 1, GL_FALSE, projectionMatrix); GLU_EXPECT_NO_ERROR(gl.getError(), "glUniformMatrix4fv"); gl.uniform1i(texLocation, 0); GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1i"); gl.texParameterf(target, GL_TEXTURE_MAX_ANISOTROPY_EXT, anisoDegree); GLU_EXPECT_NO_ERROR(gl.getError(), "texParameterfv"); gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f); GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor"); gl.clear(GL_COLOR_BUFFER_BIT); GLU_EXPECT_NO_ERROR(gl.getError(), "glClear"); gl.enableVertexAttribArray(0); GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray"); gl.enableVertexAttribArray(1); GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray"); GLint attrLocationVertex = gl.getAttribLocation(program.getProgram(), "vertex"); GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation"); GLint attrLocationInTexCoord = gl.getAttribLocation(program.getProgram(), "inTexCoord"); GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation"); GLuint strideSize = (3 + texCoordDim) * sizeof(GLfloat); gl.vertexAttribPointer(attrLocationVertex, 3, GL_FLOAT, GL_FALSE, strideSize, DE_NULL); GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer"); gl.vertexAttribPointer(attrLocationInTexCoord, texCoordDim, GL_FLOAT, GL_FALSE, strideSize, (GLvoid*)(3 * sizeof(GLfloat))); GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer"); gl.drawArrays(GL_TRIANGLE_STRIP, 0, 4); GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArray"); gl.disableVertexAttribArray(0); GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray"); gl.disableVertexAttribArray(1); GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray"); if (vbo) { gl.deleteBuffers(1, &vbo); GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteBuffers"); } if (vao) { gl.deleteVertexArrays(1, &vao); GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteVertexArrays"); } return true; }
/** Generate texture and set filtering parameters. * * @param gl OpenGL functions wrapper * @param target Texture target * @param internalFormat Texture internal format */ void TextureFilterAnisotropicDrawingTestCase::generateTexture(const glw::Functions& gl, GLenum target) { gl.genTextures(1, &m_texture); GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures"); gl.bindTexture(target, m_texture); GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture"); gl.texParameteri(target, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR); GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri"); gl.texParameteri(target, GL_TEXTURE_MAG_FILTER, GL_LINEAR); GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri"); gl.texParameteri(target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE); GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri"); gl.texParameteri(target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE); GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri"); gl.texParameteri(target, GL_TEXTURE_MAX_LEVEL, 1); GLU_EXPECT_NO_ERROR(gl.getError(), "glTexParameteri"); }
/** Verify if texParameter*, getTexParameter* queries for GL_TEXTURE_MAX_ANISOTROPY_EXT pname works as expected. * * @param gl OpenGL functions wrapper * * @return Returns true if queries test passed, false otherwise. */ bool TextureFilterAnisotropicQueriesTestCase::verifyTexParameters(const glw::Functions& gl) { GLint iValue; gl.getTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &iValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameteriv"); // Verify initial integer value which should be equal to 1 if (iValue != 1) { m_testCtx.getLog() << tcu::TestLog::Message << "GetTexParameteriv failed. Expected value: 1, Queried value: " << iValue << tcu::TestLog::EndMessage; return false; } GLfloat fValue; gl.getTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &fValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameterfv"); // Verify initial float value which should be equal to 1.0f if (fValue != 1.0f) { m_testCtx.getLog() << tcu::TestLog::Message << "GetTexParameterfv failed. Expected value: 1.0, Queried value: " << iValue << tcu::TestLog::EndMessage; return false; } // Set custom integer value and verify it iValue = 2; gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, iValue); GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteri"); gl.getTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &iValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameteriv"); if (iValue != 2) { m_testCtx.getLog() << tcu::TestLog::Message << "texParameteri failed. Expected value: 2, Queried value: " << iValue << tcu::TestLog::EndMessage; return false; } // Set custom float value and verify it fValue = 1.5f; gl.texParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, fValue); GLU_EXPECT_NO_ERROR(gl.getError(), "texParameterf"); gl.getTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &fValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameterfv"); if (fValue != 1.5f) { m_testCtx.getLog() << tcu::TestLog::Message << "texParameterf failed. Expected value: 1.5, Queried value: " << fValue << tcu::TestLog::EndMessage; return false; } // Set custom integer value and verify it iValue = 1; gl.texParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &iValue); GLU_EXPECT_NO_ERROR(gl.getError(), "texParameteriv"); gl.getTexParameteriv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &iValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameteriv"); if (iValue != 1) { m_testCtx.getLog() << tcu::TestLog::Message << "texParameteriv failed. Expected value: 1, Queried value: " << iValue << tcu::TestLog::EndMessage; return false; } // Set custom float value and verify it fValue = 2.0f; gl.texParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &fValue); GLU_EXPECT_NO_ERROR(gl.getError(), "texParameterfv"); gl.getTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &fValue); GLU_EXPECT_NO_ERROR(gl.getError(), "getTexParameterfv"); if (fValue != 2.0f) { m_testCtx.getLog() << tcu::TestLog::Message << "texParameterfv failed. Expected value: 2.0, Queried value: " << fValue << tcu::TestLog::EndMessage; return false; } // Set texture filter anisotropic to 0.9f and check if INVALID_VALUE error is generated fValue = 0.9f; gl.texParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAX_ANISOTROPY_EXT, &fValue); GLint error = gl.getError(); if (error != GL_INVALID_VALUE) { m_testCtx.getLog() << tcu::TestLog::Message << "texParameterfv failed for values less then 1.0f. Expected INVALID_VALUE error. Generated error: " << glu::getErrorName(error) << tcu::TestLog::EndMessage; return false; } return true; }