xref: /aosp_15_r20/external/deqp/modules/glshared/glsRandomShaderCase.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * 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 Random shader test case.
 *//*--------------------------------------------------------------------*/

#include "glsRandomShaderCase.hpp"

#include "gluShaderProgram.hpp"
#include "gluPixelTransfer.hpp"
#include "gluTextureUtil.hpp"
#include "gluStrUtil.hpp"

#include "tcuImageCompare.hpp"
#include "tcuTestLog.hpp"

#include "deRandom.hpp"
#include "deStringUtil.hpp"

#include "rsgProgramGenerator.hpp"
#include "rsgProgramExecutor.hpp"
#include "rsgUtils.hpp"

#include "tcuTextureUtil.hpp"
#include "tcuRenderTarget.hpp"

#include "glw.h"
#include "glwFunctions.hpp"

using std::map;
using std::pair;
using std::string;
using std::vector;

namespace deqp
{
namespace gls
{

enum
{
    VIEWPORT_WIDTH  = 64,
    VIEWPORT_HEIGHT = 64,

    TEXTURE_2D_WIDTH     = 64,
    TEXTURE_2D_HEIGHT    = 64,
    TEXTURE_2D_FORMAT    = GL_RGBA,
    TEXTURE_2D_DATA_TYPE = GL_UNSIGNED_BYTE,

    TEXTURE_CUBE_SIZE      = 16,
    TEXTURE_CUBE_FORMAT    = GL_RGBA,
    TEXTURE_CUBE_DATA_TYPE = GL_UNSIGNED_BYTE,

    TEXTURE_WRAP_S = GL_CLAMP_TO_EDGE,
    TEXTURE_WRAP_T = GL_CLAMP_TO_EDGE,

    TEXTURE_MIN_FILTER = GL_LINEAR,
    TEXTURE_MAG_FILTER = GL_LINEAR
};

VertexArray::VertexArray(const rsg::ShaderInput *input, int numVertices)
    : m_input(input)
    , m_vertices(input->getVariable()->getType().getNumElements() * numVertices)
{
}

TextureManager::TextureManager(void)
{
}

TextureManager::~TextureManager(void)
{
}

void TextureManager::bindTexture(int unit, const glu::Texture2D *tex2D)
{
    m_tex2D[unit] = tex2D;
}

void TextureManager::bindTexture(int unit, const glu::TextureCube *texCube)
{
    m_texCube[unit] = texCube;
}

inline vector<pair<int, const glu::Texture2D *>> TextureManager::getBindings2D(void) const
{
    vector<pair<int, const glu::Texture2D *>> bindings;
    for (map<int, const glu::Texture2D *>::const_iterator i = m_tex2D.begin(); i != m_tex2D.end(); i++)
        bindings.push_back(*i);
    return bindings;
}

inline vector<pair<int, const glu::TextureCube *>> TextureManager::getBindingsCube(void) const
{
    vector<pair<int, const glu::TextureCube *>> bindings;
    for (map<int, const glu::TextureCube *>::const_iterator i = m_texCube.begin(); i != m_texCube.end(); i++)
        bindings.push_back(*i);
    return bindings;
}

RandomShaderCase::RandomShaderCase(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const char *name,
                                   const char *description, const rsg::ProgramParameters &params)
    : tcu::TestCase(testCtx, name, description)
    , m_renderCtx(renderCtx)
    , m_parameters(params)
    , m_gridWidth(1)
    , m_gridHeight(1)
    , m_vertexShader(rsg::Shader::TYPE_VERTEX)
    , m_fragmentShader(rsg::Shader::TYPE_FRAGMENT)
    , m_tex2D(DE_NULL)
    , m_texCube(DE_NULL)
{
}

RandomShaderCase::~RandomShaderCase(void)
{
    delete m_tex2D;
    delete m_texCube;
}

void RandomShaderCase::init(void)
{
    // Generate shaders
    rsg::ProgramGenerator programGenerator;
    programGenerator.generate(m_parameters, m_vertexShader, m_fragmentShader);

    checkShaderLimits(m_vertexShader);
    checkShaderLimits(m_fragmentShader);
    checkProgramLimits(m_vertexShader, m_fragmentShader);

    // Compute uniform values
    std::vector<const rsg::ShaderInput *> unifiedUniforms;
    de::Random rnd(m_parameters.seed);
    rsg::computeUnifiedUniforms(m_vertexShader, m_fragmentShader, unifiedUniforms);
    rsg::computeUniformValues(rnd, m_uniforms, unifiedUniforms);

    // Generate vertices
    const vector<rsg::ShaderInput *> &inputs = m_vertexShader.getInputs();
    int numVertices                          = (m_gridWidth + 1) * (m_gridHeight + 1);

    for (vector<rsg::ShaderInput *>::const_iterator i = inputs.begin(); i != inputs.end(); i++)
    {
        const rsg::ShaderInput *input         = *i;
        rsg::ConstValueRangeAccess valueRange = input->getValueRange();
        int numComponents                     = input->getVariable()->getType().getNumElements();
        VertexArray vtxArray(input, numVertices);
        bool isPosition = string(input->getVariable()->getName()) == "dEQP_Position";

        TCU_CHECK(input->getVariable()->getType().getBaseType() == rsg::VariableType::TYPE_FLOAT);

        for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx++)
        {
            int y      = vtxNdx / (m_gridWidth + 1);
            int x      = vtxNdx - y * (m_gridWidth + 1);
            float xf   = (float)x / (float)m_gridWidth;
            float yf   = (float)y / (float)m_gridHeight;
            float *dst = &vtxArray.getVertices()[vtxNdx * numComponents];

            if (isPosition)
            {
                // Position attribute gets special interpolation handling.
                DE_ASSERT(numComponents == 4);
                dst[0] = -1.0f + xf * 2.0f;
                dst[1] = 1.0f + yf * -2.0f;
                dst[2] = 0.0f;
                dst[3] = 1.0f;
            }
            else
            {
                for (int compNdx = 0; compNdx < numComponents; compNdx++)
                {
                    float minVal = valueRange.getMin().component(compNdx).asFloat();
                    float maxVal = valueRange.getMax().component(compNdx).asFloat();
                    float xd, yd;

                    rsg::getVertexInterpolationCoords(xd, yd, xf, yf, compNdx);

                    float f = (xd + yd) / 2.0f;

                    dst[compNdx] = minVal + f * (maxVal - minVal);
                }
            }
        }

        m_vertexArrays.push_back(vtxArray);
    }

    // Generate indices
    int numQuads   = m_gridWidth * m_gridHeight;
    int numIndices = numQuads * 6;
    m_indices.resize(numIndices);
    for (int quadNdx = 0; quadNdx < numQuads; quadNdx++)
    {
        int quadY = quadNdx / (m_gridWidth);
        int quadX = quadNdx - quadY * m_gridWidth;

        m_indices[quadNdx * 6 + 0] = (uint16_t)(quadX + quadY * (m_gridWidth + 1));
        m_indices[quadNdx * 6 + 1] = (uint16_t)(quadX + (quadY + 1) * (m_gridWidth + 1));
        m_indices[quadNdx * 6 + 2] = (uint16_t)(quadX + quadY * (m_gridWidth + 1) + 1);
        m_indices[quadNdx * 6 + 3] = (uint16_t)(m_indices[quadNdx * 6 + 2]);
        m_indices[quadNdx * 6 + 4] = (uint16_t)(m_indices[quadNdx * 6 + 1]);
        m_indices[quadNdx * 6 + 5] = (uint16_t)(quadX + (quadY + 1) * (m_gridWidth + 1) + 1);
    }

    // Create textures.
    for (vector<rsg::VariableValue>::const_iterator uniformIter = m_uniforms.begin(); uniformIter != m_uniforms.end();
         uniformIter++)
    {
        const rsg::VariableType &type = uniformIter->getVariable()->getType();

        if (!type.isSampler())
            continue;

        int unitNdx = uniformIter->getValue().asInt(0);

        if (type == rsg::VariableType(rsg::VariableType::TYPE_SAMPLER_2D, 1))
            m_texManager.bindTexture(unitNdx, getTex2D());
        else if (type == rsg::VariableType(rsg::VariableType::TYPE_SAMPLER_CUBE, 1))
            m_texManager.bindTexture(unitNdx, getTexCube());
        else
            DE_ASSERT(false);
    }
}

static int getNumSamplerUniforms(const std::vector<rsg::ShaderInput *> &uniforms)
{
    int numSamplers = 0;

    for (std::vector<rsg::ShaderInput *>::const_iterator it = uniforms.begin(); it != uniforms.end(); ++it)
    {
        if ((*it)->getVariable()->getType().isSampler())
            ++numSamplers;
    }

    return numSamplers;
}

void RandomShaderCase::checkShaderLimits(const rsg::Shader &shader) const
{
    const int numRequiredSamplers = getNumSamplerUniforms(shader.getUniforms());

    if (numRequiredSamplers > 0)
    {
        const GLenum pname = (shader.getType() == rsg::Shader::TYPE_VERTEX) ? (GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS) :
                                                                              (GL_MAX_TEXTURE_IMAGE_UNITS);
        int numSupported   = -1;
        GLenum error;

        m_renderCtx.getFunctions().getIntegerv(pname, &numSupported);
        error = m_renderCtx.getFunctions().getError();

        if (error != GL_NO_ERROR)
            throw tcu::TestError("Limit query failed: " + de::toString(glu::getErrorStr(error)));

        if (numSupported < numRequiredSamplers)
            throw tcu::NotSupportedError("Shader requires " + de::toString(numRequiredSamplers) +
                                         " sampler(s). Implementation supports " + de::toString(numSupported));
    }
}

void RandomShaderCase::checkProgramLimits(const rsg::Shader &vtxShader, const rsg::Shader &frgShader) const
{
    const int numRequiredCombinedSamplers =
        getNumSamplerUniforms(vtxShader.getUniforms()) + getNumSamplerUniforms(frgShader.getUniforms());

    if (numRequiredCombinedSamplers > 0)
    {
        int numSupported = -1;
        GLenum error;

        m_renderCtx.getFunctions().getIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &numSupported);
        error = m_renderCtx.getFunctions().getError();

        if (error != GL_NO_ERROR)
            throw tcu::TestError("Limit query failed: " + de::toString(glu::getErrorStr(error)));

        if (numSupported < numRequiredCombinedSamplers)
            throw tcu::NotSupportedError("Program requires " + de::toString(numRequiredCombinedSamplers) +
                                         " sampler(s). Implementation supports " + de::toString(numSupported));
    }
}

const glu::Texture2D *RandomShaderCase::getTex2D(void)
{
    if (!m_tex2D)
    {
        m_tex2D = new glu::Texture2D(m_renderCtx, TEXTURE_2D_FORMAT, TEXTURE_2D_DATA_TYPE, TEXTURE_2D_WIDTH,
                                     TEXTURE_2D_HEIGHT);

        m_tex2D->getRefTexture().allocLevel(0);
        tcu::fillWithComponentGradients(m_tex2D->getRefTexture().getLevel(0), tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f),
                                        tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f));
        m_tex2D->upload();

        // Setup parameters.
        glBindTexture(GL_TEXTURE_2D, m_tex2D->getGLTexture());
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, TEXTURE_WRAP_S);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, TEXTURE_WRAP_T);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, TEXTURE_MIN_FILTER);
        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, TEXTURE_MAG_FILTER);

        GLU_CHECK();
    }

    return m_tex2D;
}

const glu::TextureCube *RandomShaderCase::getTexCube(void)
{
    if (!m_texCube)
    {
        m_texCube = new glu::TextureCube(m_renderCtx, TEXTURE_CUBE_FORMAT, TEXTURE_CUBE_DATA_TYPE, TEXTURE_CUBE_SIZE);

        static const tcu::Vec4 gradients[tcu::CUBEFACE_LAST][2] = {
            {tcu::Vec4(-1.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)}, // negative x
            {tcu::Vec4(0.0f, -1.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)},  // positive x
            {tcu::Vec4(-1.0f, 0.0f, -1.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)},  // negative y
            {tcu::Vec4(-1.0f, -1.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)},  // positive y
            {tcu::Vec4(-1.0f, -1.0f, -1.0f, 0.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f)}, // negative z
            {tcu::Vec4(0.0f, 0.0f, 0.0f, 2.0f), tcu::Vec4(1.0f, 1.0f, 1.0f, 0.0f)}     // positive z
        };

        // Fill level 0.
        for (int face = 0; face < tcu::CUBEFACE_LAST; face++)
        {
            m_texCube->getRefTexture().allocLevel((tcu::CubeFace)face, 0);
            tcu::fillWithComponentGradients(m_texCube->getRefTexture().getLevelFace(0, (tcu::CubeFace)face),
                                            gradients[face][0], gradients[face][1]);
        }

        m_texCube->upload();

        // Setup parameters.
        glBindTexture(GL_TEXTURE_CUBE_MAP, m_texCube->getGLTexture());
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_S, TEXTURE_WRAP_S);
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_WRAP_T, TEXTURE_WRAP_T);
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MIN_FILTER, TEXTURE_MIN_FILTER);
        glTexParameteri(GL_TEXTURE_CUBE_MAP, GL_TEXTURE_MAG_FILTER, TEXTURE_MAG_FILTER);

        GLU_CHECK();
    }

    return m_texCube;
}

void RandomShaderCase::deinit(void)
{
    delete m_tex2D;
    delete m_texCube;

    m_tex2D   = DE_NULL;
    m_texCube = DE_NULL;

    // Free up memory
    m_vertexArrays.clear();
    m_indices.clear();
}

namespace
{

void setUniformValue(int location, rsg::ConstValueAccess value)
{
    DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(float));
    DE_STATIC_ASSERT(sizeof(rsg::Scalar) == sizeof(int));

    switch (value.getType().getBaseType())
    {
    case rsg::VariableType::TYPE_FLOAT:
        switch (value.getType().getNumElements())
        {
        case 1:
            glUniform1fv(location, 1, (float *)value.value().getValuePtr());
            break;
        case 2:
            glUniform2fv(location, 1, (float *)value.value().getValuePtr());
            break;
        case 3:
            glUniform3fv(location, 1, (float *)value.value().getValuePtr());
            break;
        case 4:
            glUniform4fv(location, 1, (float *)value.value().getValuePtr());
            break;
        default:
            TCU_FAIL("Unsupported type");
        }
        break;

    case rsg::VariableType::TYPE_INT:
    case rsg::VariableType::TYPE_BOOL:
    case rsg::VariableType::TYPE_SAMPLER_2D:
    case rsg::VariableType::TYPE_SAMPLER_CUBE:
        switch (value.getType().getNumElements())
        {
        case 1:
            glUniform1iv(location, 1, (int *)value.value().getValuePtr());
            break;
        case 2:
            glUniform2iv(location, 1, (int *)value.value().getValuePtr());
            break;
        case 3:
            glUniform3iv(location, 1, (int *)value.value().getValuePtr());
            break;
        case 4:
            glUniform4iv(location, 1, (int *)value.value().getValuePtr());
            break;
        default:
            TCU_FAIL("Unsupported type");
        }
        break;

    default:
        TCU_FAIL("Unsupported type");
    }
}

tcu::MessageBuilder &operator<<(tcu::MessageBuilder &message, rsg::ConstValueAccess value)
{
    const char *scalarType = DE_NULL;
    const char *vecType    = DE_NULL;

    switch (value.getType().getBaseType())
    {
    case rsg::VariableType::TYPE_FLOAT:
        scalarType = "float";
        vecType    = "vec";
        break;
    case rsg::VariableType::TYPE_INT:
        scalarType = "int";
        vecType    = "ivec";
        break;
    case rsg::VariableType::TYPE_BOOL:
        scalarType = "bool";
        vecType    = "bvec";
        break;
    case rsg::VariableType::TYPE_SAMPLER_2D:
        scalarType = "sampler2D";
        break;
    case rsg::VariableType::TYPE_SAMPLER_CUBE:
        scalarType = "samplerCube";
        break;
    default:
        TCU_FAIL("Unsupported type.");
    }

    int numElements = value.getType().getNumElements();
    if (numElements == 1)
        message << scalarType << "(";
    else
        message << vecType << numElements << "(";

    for (int elementNdx = 0; elementNdx < numElements; elementNdx++)
    {
        if (elementNdx > 0)
            message << ", ";

        switch (value.getType().getBaseType())
        {
        case rsg::VariableType::TYPE_FLOAT:
            message << value.component(elementNdx).asFloat();
            break;
        case rsg::VariableType::TYPE_INT:
            message << value.component(elementNdx).asInt();
            break;
        case rsg::VariableType::TYPE_BOOL:
            message << (value.component(elementNdx).asBool() ? "true" : "false");
            break;
        case rsg::VariableType::TYPE_SAMPLER_2D:
            message << value.component(elementNdx).asInt();
            break;
        case rsg::VariableType::TYPE_SAMPLER_CUBE:
            message << value.component(elementNdx).asInt();
            break;
        default:
            DE_ASSERT(false);
        }
    }

    message << ")";

    return message;
}

tcu::MessageBuilder &operator<<(tcu::MessageBuilder &message, rsg::ConstValueRangeAccess valueRange)
{
    return message << valueRange.getMin() << " -> " << valueRange.getMax();
}

} // namespace

RandomShaderCase::IterateResult RandomShaderCase::iterate(void)
{
    tcu::TestLog &log = m_testCtx.getLog();

    // Compile program
    glu::ShaderProgram program(m_renderCtx,
                               glu::makeVtxFragSources(m_vertexShader.getSource(), m_fragmentShader.getSource()));
    log << program;

    if (!program.isOk())
    {
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Failed to compile shader");
        return STOP;
    }

    // Compute random viewport
    de::Random rnd(m_parameters.seed);
    int viewportWidth  = de::min<int>(VIEWPORT_WIDTH, m_renderCtx.getRenderTarget().getWidth());
    int viewportHeight = de::min<int>(VIEWPORT_HEIGHT, m_renderCtx.getRenderTarget().getHeight());
    int viewportX      = rnd.getInt(0, m_renderCtx.getRenderTarget().getWidth() - viewportWidth);
    int viewportY      = rnd.getInt(0, m_renderCtx.getRenderTarget().getHeight() - viewportHeight);
    bool hasAlpha      = m_renderCtx.getRenderTarget().getPixelFormat().alphaBits > 0;
    tcu::TextureLevel rendered(tcu::TextureFormat(hasAlpha ? tcu::TextureFormat::RGBA : tcu::TextureFormat::RGB,
                                                  tcu::TextureFormat::UNORM_INT8),
                               viewportWidth, viewportHeight);
    tcu::TextureLevel reference(tcu::TextureFormat(hasAlpha ? tcu::TextureFormat::RGBA : tcu::TextureFormat::RGB,
                                                   tcu::TextureFormat::UNORM_INT8),
                                viewportWidth, viewportHeight);

    // Reference program executor.
    rsg::ProgramExecutor executor(reference.getAccess(), m_gridWidth, m_gridHeight);

    GLU_CHECK_CALL(glUseProgram(program.getProgram()));

    // Set up attributes
    for (vector<VertexArray>::const_iterator attribIter = m_vertexArrays.begin(); attribIter != m_vertexArrays.end();
         attribIter++)
    {
        GLint location = glGetAttribLocation(program.getProgram(), attribIter->getName());

        // Print to log.
        log << tcu::TestLog::Message << "attribute[" << location << "]: " << attribIter->getName() << " = "
            << attribIter->getValueRange() << tcu::TestLog::EndMessage;

        if (location >= 0)
        {
            glVertexAttribPointer(location, attribIter->getNumComponents(), GL_FLOAT, GL_FALSE, 0,
                                  &attribIter->getVertices()[0]);
            glEnableVertexAttribArray(location);
        }
    }
    GLU_CHECK_MSG("After attribute setup");

    // Uniforms
    for (vector<rsg::VariableValue>::const_iterator uniformIter = m_uniforms.begin(); uniformIter != m_uniforms.end();
         uniformIter++)
    {
        GLint location = glGetUniformLocation(program.getProgram(), uniformIter->getVariable()->getName());

        log << tcu::TestLog::Message << "uniform[" << location << "]: " << uniformIter->getVariable()->getName()
            << " = " << uniformIter->getValue() << tcu::TestLog::EndMessage;

        if (location >= 0)
            setUniformValue(location, uniformIter->getValue());
    }
    GLU_CHECK_MSG("After uniform setup");

    // Textures
    vector<pair<int, const glu::Texture2D *>> tex2DBindings     = m_texManager.getBindings2D();
    vector<pair<int, const glu::TextureCube *>> texCubeBindings = m_texManager.getBindingsCube();

    for (vector<pair<int, const glu::Texture2D *>>::const_iterator i = tex2DBindings.begin(); i != tex2DBindings.end();
         i++)
    {
        int unitNdx                   = i->first;
        const glu::Texture2D *texture = i->second;

        glActiveTexture(GL_TEXTURE0 + unitNdx);
        glBindTexture(GL_TEXTURE_2D, texture->getGLTexture());

        executor.setTexture(unitNdx, &texture->getRefTexture(),
                            glu::mapGLSampler(TEXTURE_WRAP_S, TEXTURE_WRAP_T, TEXTURE_MIN_FILTER, TEXTURE_MAG_FILTER));
    }
    GLU_CHECK_MSG("After 2D texture setup");

    for (vector<pair<int, const glu::TextureCube *>>::const_iterator i = texCubeBindings.begin();
         i != texCubeBindings.end(); i++)
    {
        int unitNdx                     = i->first;
        const glu::TextureCube *texture = i->second;

        glActiveTexture(GL_TEXTURE0 + unitNdx);
        glBindTexture(GL_TEXTURE_CUBE_MAP, texture->getGLTexture());

        executor.setTexture(unitNdx, &texture->getRefTexture(),
                            glu::mapGLSampler(TEXTURE_WRAP_S, TEXTURE_WRAP_T, TEXTURE_MIN_FILTER, TEXTURE_MAG_FILTER));
    }
    GLU_CHECK_MSG("After cubemap setup");

    // Draw and read
    glViewport(viewportX, viewportY, viewportWidth, viewportHeight);
    glDrawElements(GL_TRIANGLES, (GLsizei)m_indices.size(), GL_UNSIGNED_SHORT, &m_indices[0]);
    glFlush();
    GLU_CHECK_MSG("Draw");

    // Render reference while GPU is doing work
    executor.execute(m_vertexShader, m_fragmentShader, m_uniforms);

    if (rendered.getFormat().order != tcu::TextureFormat::RGBA ||
        rendered.getFormat().type != tcu::TextureFormat::UNORM_INT8)
    {
        // Read as GL_RGBA8
        tcu::TextureLevel readBuf(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8),
                                  rendered.getWidth(), rendered.getHeight());
        glu::readPixels(m_renderCtx, viewportX, viewportY, readBuf.getAccess());
        GLU_CHECK_MSG("Read pixels");
        tcu::copy(rendered, readBuf);
    }
    else
        glu::readPixels(m_renderCtx, viewportX, viewportY, rendered.getAccess());

    // Compare
    {
        float threshold = 0.02f;
        bool imagesOk   = tcu::fuzzyCompare(log, "Result", "Result images", reference.getAccess(), rendered.getAccess(),
                                            threshold, tcu::COMPARE_LOG_RESULT);

        if (imagesOk)
            m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
        else
            m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
    }

    return STOP;
}

} // namespace gls
} // namespace deqp