xref: /aosp_15_r20/external/deqp/modules/gles3/functional/es3fTextureUnitTests.cpp (revision 35238bce31c2a825756842865a792f8cf7f89930)

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL ES 3.0 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 Texture unit usage tests.
 *
 * \todo [2012-07-12 nuutti] Come up with a good way to make these tests faster.
 *//*--------------------------------------------------------------------*/

#include "es3fTextureUnitTests.hpp"
#include "glsTextureTestUtil.hpp"
#include "gluTextureUtil.hpp"
#include "gluContextInfo.hpp"
#include "gluTextureUtil.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuImageCompare.hpp"
#include "tcuMatrix.hpp"
#include "tcuRenderTarget.hpp"
#include "sglrContextUtil.hpp"
#include "sglrReferenceContext.hpp"
#include "sglrGLContext.hpp"
#include "deMath.h"
#include "deRandom.hpp"
#include "deStringUtil.hpp"

#include "glwEnums.hpp"
#include "glwFunctions.hpp"

using std::string;
using std::vector;
using tcu::IVec2;
using tcu::IVec3;
using tcu::Mat3;
using tcu::Mat4;
using tcu::Vec2;
using tcu::Vec3;
using tcu::Vec4;
using namespace glw; // GL types

namespace deqp
{

using namespace gls::TextureTestUtil;

namespace gles3
{
namespace Functional
{

static const int VIEWPORT_WIDTH  = 128;
static const int VIEWPORT_HEIGHT = 128;

static const int TEXTURE_WIDTH_2D  = 128;
static const int TEXTURE_HEIGHT_2D = 128;

// \note Cube map texture size is larger in order to make minifications possible - otherwise would need to display different faces at same time.
static const int TEXTURE_WIDTH_CUBE  = 256;
static const int TEXTURE_HEIGHT_CUBE = 256;

static const int TEXTURE_WIDTH_2D_ARRAY  = 64;
static const int TEXTURE_HEIGHT_2D_ARRAY = 64;
static const int TEXTURE_LAYERS_2D_ARRAY = 4;

static const int TEXTURE_WIDTH_3D  = 32;
static const int TEXTURE_HEIGHT_3D = 32;
static const int TEXTURE_DEPTH_3D  = 32;

static const int GRID_CELL_SIZE = 8;

static const GLenum s_testSizedInternalFormats[] = {
    GL_RGBA32F,    GL_RGBA32I,        GL_RGBA32UI, GL_RGBA16F,    GL_RGBA16I, GL_RGBA16UI, GL_RGBA8,       GL_RGBA8I,
    GL_RGBA8UI,    GL_SRGB8_ALPHA8,   GL_RGB10_A2, GL_RGB10_A2UI, GL_RGBA4,   GL_RGB5_A1,  GL_RGBA8_SNORM, GL_RGB8,
    GL_RGB565,     GL_R11F_G11F_B10F, GL_RGB32F,   GL_RGB32I,     GL_RGB32UI, GL_RGB16F,   GL_RGB16I,      GL_RGB16UI,
    GL_RGB8_SNORM, GL_RGB8I,          GL_RGB8UI,   GL_SRGB8,      GL_RGB9_E5, GL_RG32F,    GL_RG32I,       GL_RG32UI,
    GL_RG16F,      GL_RG16I,          GL_RG16UI,   GL_RG8,        GL_RG8I,    GL_RG8UI,    GL_RG8_SNORM,   GL_R32F,
    GL_R32I,       GL_R32UI,          GL_R16F,     GL_R16I,       GL_R16UI,   GL_R8,       GL_R8I,         GL_R8UI,
    GL_R8_SNORM};

static const GLenum s_testWrapModes[] = {
    GL_CLAMP_TO_EDGE,
    GL_REPEAT,
    GL_MIRRORED_REPEAT,
};

static const GLenum s_testMinFilters[] = {GL_NEAREST,
                                          GL_LINEAR,
                                          GL_NEAREST_MIPMAP_NEAREST,
                                          GL_LINEAR_MIPMAP_NEAREST,
                                          GL_NEAREST_MIPMAP_LINEAR,
                                          GL_LINEAR_MIPMAP_LINEAR};

static const GLenum s_testNonMipmapMinFilters[] = {GL_NEAREST, GL_LINEAR};

static const GLenum s_testNearestMinFilters[] = {GL_NEAREST, GL_NEAREST_MIPMAP_NEAREST};

static const GLenum s_testMagFilters[] = {GL_NEAREST, GL_LINEAR};

static const GLenum s_cubeFaceTargets[] = {GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
                                           GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
                                           GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z};

// Extend a 3x3 transformation matrix to an equivalent 4x4 transformation matrix (i.e. 1.0 in right-down cell, 0.0's in other new cells).
static Mat4 matExtend3To4(const Mat3 &mat)
{
    Mat4 res;
    for (int rowNdx = 0; rowNdx < 3; rowNdx++)
    {
        Vec3 row = mat.getRow(rowNdx);
        res.setRow(rowNdx, Vec4(row.x(), row.y(), row.z(), 0.0f));
    }
    res.setRow(3, Vec4(0.0f, 0.0f, 0.0f, 1.0f));

    return res;
}

static string generateMultiTexFragmentShader(int numUnits, const vector<GLenum> &unitTypes,
                                             const vector<glu::DataType> &samplerTypes)
{
    // The fragment shader calculates the average of a set of textures.

    string samplersStr;
    string matricesStr;
    string scalesStr;
    string biasesStr;
    string lookupsStr;

    string colorMultiplier = "(1.0/" + de::toString(numUnits) + ".0)";

    for (int ndx = 0; ndx < numUnits; ndx++)
    {
        string ndxStr             = de::toString(ndx);
        string samplerName        = "u_sampler" + ndxStr;
        string transformationName = "u_trans" + ndxStr;
        string scaleName          = "u_texScale" + ndxStr;
        string biasName           = "u_texBias" + ndxStr;

        samplersStr +=
            string("") + "uniform highp " + glu::getDataTypeName(samplerTypes[ndx]) + " " + samplerName + ";\n";
        matricesStr += "uniform highp mat4 " + transformationName + ";\n";
        scalesStr += "uniform highp vec4 " + scaleName + ";\n";
        biasesStr += "uniform highp vec4 " + biasName + ";\n";

        string lookupCoord = transformationName + "*vec4(v_coord, 1.0, 1.0)";

        if (unitTypes[ndx] == GL_TEXTURE_2D)
            lookupCoord = "vec2(" + lookupCoord + ")";
        else
            lookupCoord = "vec3(" + lookupCoord + ")";

        lookupsStr += "\tcolor += " + colorMultiplier + "*(vec4(texture(" + samplerName + ", " + lookupCoord + "))*" +
                      scaleName + " + " + biasName + ");\n";
    }

    return "#version 300 es\n"
           "layout(location = 0) out mediump vec4 o_color;\n" +
           samplersStr + matricesStr + scalesStr + biasesStr +
           "in highp vec2 v_coord;\n"
           "\n"
           "void main (void)\n"
           "{\n"
           "    mediump vec4 color = vec4(0.0);\n" +
           lookupsStr +
           "    o_color = color;\n"
           "}\n";
}

static sglr::pdec::ShaderProgramDeclaration generateShaderProgramDeclaration(int numUnits,
                                                                             const vector<GLenum> &unitTypes,
                                                                             const vector<glu::DataType> &samplerTypes)
{
    sglr::pdec::ShaderProgramDeclaration decl;

    decl << sglr::pdec::VertexAttribute("a_position", rr::GENERICVECTYPE_FLOAT);
    decl << sglr::pdec::VertexAttribute("a_coord", rr::GENERICVECTYPE_FLOAT);
    decl << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT);
    decl << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT);

    for (int ndx = 0; ndx < numUnits; ++ndx)
    {
        string samplerName        = "u_sampler" + de::toString(ndx);
        string transformationName = "u_trans" + de::toString(ndx);
        string scaleName          = "u_texScale" + de::toString(ndx);
        string biasName           = "u_texBias" + de::toString(ndx);

        decl << sglr::pdec::Uniform(samplerName, samplerTypes[ndx]);
        decl << sglr::pdec::Uniform(transformationName, glu::TYPE_FLOAT_MAT4);
        decl << sglr::pdec::Uniform(scaleName, glu::TYPE_FLOAT_VEC4);
        decl << sglr::pdec::Uniform(biasName, glu::TYPE_FLOAT_VEC4);
    }

    decl << sglr::pdec::VertexSource("#version 300 es\n"
                                     "in highp vec4 a_position;\n"
                                     "in highp vec2 a_coord;\n"
                                     "out highp vec2 v_coord;\n"
                                     "\n"
                                     "void main (void)\n"
                                     "{\n"
                                     "    gl_Position = a_position;\n"
                                     "    v_coord = a_coord;\n"
                                     "}\n");
    decl << sglr::pdec::FragmentSource(generateMultiTexFragmentShader(numUnits, unitTypes, samplerTypes));

    return decl;
}

// Calculates values that will be used in calculateLod().
static tcu::Vector<tcu::Vec2, 3> calculateLodDerivateParts(const Mat4 &transformation)
{
    // Calculate transformed coordinates of three screen corners.
    Vec3 trans00 = (transformation * Vec4(0.0f, 0.0f, 1.0f, 1.0f)).xyz();
    Vec3 trans01 = (transformation * Vec4(0.0f, 1.0f, 1.0f, 1.0f)).xyz();
    Vec3 trans10 = (transformation * Vec4(1.0f, 0.0f, 1.0f, 1.0f)).xyz();

    return tcu::Vector<tcu::Vec2, 3>(Vec2(trans10.x() - trans00.x(), trans01.x() - trans00.x()),
                                     Vec2(trans10.y() - trans00.y(), trans01.y() - trans00.y()),
                                     Vec2(trans10.z() - trans00.z(), trans01.z() - trans00.z()));
}

// Calculates the maximum allowed lod from derivates
static float calculateLodMax(const tcu::Vector<tcu::Vec2, 3> &derivateParts, const tcu::IVec3 &textureSize,
                             const Vec2 &screenDerivate)
{
    float dudx = derivateParts[0].x() * (float)textureSize.x() * screenDerivate.x();
    float dudy = derivateParts[0].y() * (float)textureSize.x() * screenDerivate.y();
    float dvdx = derivateParts[1].x() * (float)textureSize.y() * screenDerivate.x();
    float dvdy = derivateParts[1].y() * (float)textureSize.y() * screenDerivate.y();
    float dwdx = derivateParts[2].x() * (float)textureSize.z() * screenDerivate.x();
    float dwdy = derivateParts[2].y() * (float)textureSize.z() * screenDerivate.y();

    const float mu = de::max(de::abs(dudx), de::abs(dudy));
    const float mv = de::max(de::abs(dvdx), de::abs(dvdy));
    const float mw = de::max(de::abs(dwdx), de::abs(dwdy));
    return deFloatLog2(mu + mv + mw);
}

// Calculates the minimum allowed lod from derivates
static float calculateLodMin(const tcu::Vector<tcu::Vec2, 3> &derivateParts, const tcu::IVec3 &textureSize,
                             const Vec2 &screenDerivate)
{
    float dudx = derivateParts[0].x() * (float)textureSize.x() * screenDerivate.x();
    float dudy = derivateParts[0].y() * (float)textureSize.x() * screenDerivate.y();
    float dvdx = derivateParts[1].x() * (float)textureSize.y() * screenDerivate.x();
    float dvdy = derivateParts[1].y() * (float)textureSize.y() * screenDerivate.y();
    float dwdx = derivateParts[2].x() * (float)textureSize.z() * screenDerivate.x();
    float dwdy = derivateParts[2].y() * (float)textureSize.z() * screenDerivate.y();

    const float mu = de::max(de::abs(dudx), de::abs(dudy));
    const float mv = de::max(de::abs(dvdx), de::abs(dvdy));
    const float mw = de::max(de::abs(dwdx), de::abs(dwdy));
    return deFloatLog2(de::max(mu, de::max(mv, mw)));
}

class MultiTexShader : public sglr::ShaderProgram
{
public:
    MultiTexShader(uint32_t randSeed, int numUnits, const vector<GLenum> &unitTypes,
                   const vector<glu::DataType> &samplerTypes, const vector<Vec4> &texScales,
                   const vector<Vec4> &texBiases,
                   const vector<int> &
                       num2dArrayLayers); // \note 2d array layer "coordinate" isn't normalized, so this is needed here.

    void setUniforms(sglr::Context &context, uint32_t program) const;
    void makeSafeLods(
        const vector<IVec3> &textureSizes,
        const IVec2 &viewportSize); // Modifies texture coordinates so that LODs aren't too close to x.5 or 0.0 .

private:
    void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const;
    void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
                        const rr::FragmentShadingContext &context) const;

    int m_numUnits;
    vector<GLenum> m_unitTypes; // 2d, cube map, 2d array or 3d.
    vector<Vec4> m_texScales;
    vector<Vec4> m_texBiases;
    vector<Mat4> m_transformations;
    vector<tcu::Vector<tcu::Vec2, 3>> m_lodDerivateParts; // Parts of lod derivates; computed in init(), used in eval().
};

MultiTexShader::MultiTexShader(uint32_t randSeed, int numUnits, const vector<GLenum> &unitTypes,
                               const vector<glu::DataType> &samplerTypes, const vector<Vec4> &texScales,
                               const vector<Vec4> &texBiases, const vector<int> &num2dArrayLayers)
    : sglr::ShaderProgram(generateShaderProgramDeclaration(numUnits, unitTypes, samplerTypes))
    , m_numUnits(numUnits)
    , m_unitTypes(unitTypes)
    , m_texScales(texScales)
    , m_texBiases(texBiases)
{
    // 2d-to-cube-face transformations.
    // \note 2d coordinates range from 0 to 1 and cube face coordinates from -1 to 1, so scaling is done as well.
    static const float s_cubeTransforms[][3 * 3] = {// Face -X: (x, y, 1) -> (-1, -(2*y-1), +(2*x-1))
                                                    {0.0f, 0.0f, -1.0f, 0.0f, -2.0f, 1.0f, 2.0f, 0.0f, -1.0f},
                                                    // Face +X: (x, y, 1) -> (+1, -(2*y-1), -(2*x-1))
                                                    {0.0f, 0.0f, 1.0f, 0.0f, -2.0f, 1.0f, -2.0f, 0.0f, 1.0f},
                                                    // Face -Y: (x, y, 1) -> (+(2*x-1), -1, -(2*y-1))
                                                    {2.0f, 0.0f, -1.0f, 0.0f, 0.0f, -1.0f, 0.0f, -2.0f, 1.0f},
                                                    // Face +Y: (x, y, 1) -> (+(2*x-1), +1, +(2*y-1))
                                                    {2.0f, 0.0f, -1.0f, 0.0f, 0.0f, 1.0f, 0.0f, 2.0f, -1.0f},
                                                    // Face -Z: (x, y, 1) -> (-(2*x-1), -(2*y-1), -1)
                                                    {-2.0f, 0.0f, 1.0f, 0.0f, -2.0f, 1.0f, 0.0f, 0.0f, -1.0f},
                                                    // Face +Z: (x, y, 1) -> (+(2*x-1), -(2*y-1), +1)
                                                    {2.0f, 0.0f, -1.0f, 0.0f, -2.0f, 1.0f, 0.0f, 0.0f, 1.0f}};

    // Generate transformation matrices.

    de::Random rnd(randSeed);

    m_transformations.reserve(m_numUnits);
    m_lodDerivateParts.reserve(m_numUnits);

    int tex2dArrayNdx = 0; // Keep track of 2d texture array index.

    DE_ASSERT((int)m_unitTypes.size() == m_numUnits);

    for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++)
    {
        if (m_unitTypes[unitNdx] == GL_TEXTURE_2D)
        {
            float rotAngle           = rnd.getFloat(0.0f, 2.0f * DE_PI);
            float xScaleFactor       = rnd.getFloat(0.7f, 1.5f);
            float yScaleFactor       = rnd.getFloat(0.7f, 1.5f);
            float xShearAmount       = rnd.getFloat(0.0f, 0.5f);
            float yShearAmount       = rnd.getFloat(0.0f, 0.5f);
            float xTranslationAmount = rnd.getFloat(-0.5f, 0.5f);
            float yTranslationAmount = rnd.getFloat(-0.5f, 0.5f);

            static const float
                tempOffsetData[3 * 3] = // For temporarily centering the coordinates to get nicer transformations.
                {1.0f, 0.0f, -0.5f, 0.0f, 1.0f, -0.5f, 0.0f, 0.0f, 1.0f};
            float rotTransfData[3 * 3]         = {deFloatCos(rotAngle),
                                                  -deFloatSin(rotAngle),
                                                  0.0f,
                                                  deFloatSin(rotAngle),
                                                  deFloatCos(rotAngle),
                                                  0.0f,
                                                  0.0f,
                                                  0.0f,
                                                  1.0f};
            float scaleTransfData[3 * 3]       = {xScaleFactor, 0.0f, 0.0f, 0.0f, yScaleFactor, 0.0f, 0.0f, 0.0f, 1.0f};
            float xShearTransfData[3 * 3]      = {1.0f, xShearAmount, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f};
            float yShearTransfData[3 * 3]      = {1.0f, 0.0f, 0.0f, yShearAmount, 1.0f, 0.0f, 0.0f, 0.0f, 1.0f};
            float translationTransfData[3 * 3] = {1.0f, 0.0f, xTranslationAmount, 0.0f, 1.0f, yTranslationAmount, 0.0f,
                                                  0.0f, 1.0f};

            Mat4 transformation = matExtend3To4(Mat3(tempOffsetData) * Mat3(translationTransfData) *
                                                Mat3(rotTransfData) * Mat3(scaleTransfData) * Mat3(xShearTransfData) *
                                                Mat3(yShearTransfData) * (Mat3(tempOffsetData) * (-1.0f)));

            m_lodDerivateParts.push_back(calculateLodDerivateParts(transformation));
            m_transformations.push_back(transformation);
        }
        else if (m_unitTypes[unitNdx] == GL_TEXTURE_CUBE_MAP)
        {
            DE_STATIC_ASSERT((int)tcu::CUBEFACE_LAST == DE_LENGTH_OF_ARRAY(s_cubeTransforms));

            float planarTransData[3 * 3];

            // In case of a cube map, we only want to render one face, so the transformation needs to be restricted - only enlarging scaling is done.

            for (int i = 0; i < DE_LENGTH_OF_ARRAY(planarTransData); i++)
            {
                if (i == 0 || i == 4)
                    planarTransData[i] = rnd.getFloat(0.1f, 0.9f); // Two first diagonal cells control the scaling.
                else if (i == 8)
                    planarTransData[i] = 1.0f;
                else
                    planarTransData[i] = 0.0f;
            }

            int faceNdx = rnd.getInt(0, (int)tcu::CUBEFACE_LAST - 1);
            Mat3 planarTrans(planarTransData); // Planar, face-agnostic transformation.
            Mat4 finalTrans = matExtend3To4(
                Mat3(s_cubeTransforms[faceNdx]) *
                planarTrans); // Final transformation from planar to cube map coordinates, including the transformation just generated.
            Mat4 planarTrans4x4 = matExtend3To4(planarTrans);

            m_lodDerivateParts.push_back(calculateLodDerivateParts(planarTrans4x4));
            m_transformations.push_back(finalTrans);
        }
        else
        {
            DE_ASSERT(m_unitTypes[unitNdx] == GL_TEXTURE_3D || m_unitTypes[unitNdx] == GL_TEXTURE_2D_ARRAY);

            float transData[4 * 4];

            for (int i = 0; i < 4 * 4; i++)
            {
                float sign   = rnd.getBool() ? 1.0f : -1.0f;
                transData[i] = rnd.getFloat(0.7f, 1.4f) * sign;
            }

            Mat4 transformation(transData);

            if (m_unitTypes[unitNdx] == GL_TEXTURE_2D_ARRAY)
            {
                // Z direction: Translate by 0.5 and scale by layer amount.

                float numLayers = (float)num2dArrayLayers[tex2dArrayNdx];

                static const float zTranslationTransfData[4 * 4] = {1.0f, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
                                                                    0.0f, 0.0f, 1.0f, 0.5f, 0.0f, 0.0f, 0.0f, 1.0f};

                float zScaleTransfData[4 * 4] = {1.0f, 0.0f, 0.0f,      0.0f, 0.0f, 1.0f, 0.0f, 0.0f,
                                                 0.0f, 0.0f, numLayers, 0.0f, 0.0f, 0.0f, 0.0f, 1.0f};

                transformation = transformation * Mat4(zScaleTransfData) * Mat4(zTranslationTransfData);

                tex2dArrayNdx++;
            }

            m_lodDerivateParts.push_back(calculateLodDerivateParts(transformation));
            m_transformations.push_back(Mat4(transformation));
        }
    }
}

void MultiTexShader::setUniforms(sglr::Context &ctx, uint32_t program) const
{
    ctx.useProgram(program);

    // Sampler and matrix uniforms.

    for (int ndx = 0; ndx < m_numUnits; ndx++)
    {
        string ndxStr = de::toString(ndx);

        ctx.uniform1i(ctx.getUniformLocation(program, ("u_sampler" + ndxStr).c_str()), ndx);
        ctx.uniformMatrix4fv(ctx.getUniformLocation(program, ("u_trans" + ndxStr).c_str()), 1, GL_FALSE,
                             (GLfloat *)&m_transformations[ndx].getColumnMajorData()[0]);
        ctx.uniform4fv(ctx.getUniformLocation(program, ("u_texScale" + ndxStr).c_str()), 1, m_texScales[ndx].getPtr());
        ctx.uniform4fv(ctx.getUniformLocation(program, ("u_texBias" + ndxStr).c_str()), 1, m_texBiases[ndx].getPtr());
    }
}

void MultiTexShader::makeSafeLods(const vector<IVec3> &textureSizes, const IVec2 &viewportSize)
{
    DE_ASSERT((int)textureSizes.size() == m_numUnits);

    static const float shrinkScaleMat2dData[3 * 3] = {0.95f, 0.0f, 0.0f, 0.0f, 0.95f, 0.0f, 0.0f, 0.0f, 1.0f};
    static const float shrinkScaleMat3dData[3 * 3] = {0.95f, 0.0f, 0.0f, 0.0f, 0.95f, 0.0f, 0.0f, 0.0f, 0.95f};
    Mat4 shrinkScaleMat2d                          = matExtend3To4(Mat3(shrinkScaleMat2dData));
    Mat4 shrinkScaleMat3d                          = matExtend3To4(Mat3(shrinkScaleMat3dData));

    Vec2 screenDerivate(1.0f / (float)viewportSize.x(), 1.0f / (float)viewportSize.y());

    for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++)
    {
        // As long as LOD is too close to 0.0 or is positive and too close to a something-and-a-half (0.5, 1.5, 2.5 etc) or allowed lod range could round to different levels, zoom in a little to get a safer LOD.
        for (;;)
        {
            const float threshold = 0.1f;
            const float epsilon   = 0.01f;

            const float lodMax = calculateLodMax(m_lodDerivateParts[unitNdx], textureSizes[unitNdx], screenDerivate);
            const float lodMin = calculateLodMin(m_lodDerivateParts[unitNdx], textureSizes[unitNdx], screenDerivate);

            const int32_t maxLevel =
                (lodMax + epsilon < 0.5f) ? (0) : (deCeilFloatToInt32(lodMax + epsilon + 0.5f) - 1);
            const int32_t minLevel =
                (lodMin - epsilon < 0.5f) ? (0) : (deCeilFloatToInt32(lodMin - epsilon + 0.5f) - 1);

            if (de::abs(lodMax) < threshold || (lodMax > 0.0f && de::abs(deFloatFrac(lodMax) - 0.5f) < threshold) ||
                de::abs(lodMin) < threshold || (lodMin > 0.0f && de::abs(deFloatFrac(lodMin) - 0.5f) < threshold) ||
                maxLevel != minLevel)
            {
                m_transformations[unitNdx] =
                    (m_unitTypes[unitNdx] == GL_TEXTURE_3D ? shrinkScaleMat3d : shrinkScaleMat2d) *
                    m_transformations[unitNdx];
                m_lodDerivateParts[unitNdx] = calculateLodDerivateParts(m_transformations[unitNdx]);
            }
            else
                break;
        }
    }
}

void MultiTexShader::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
                                   const int numPackets) const
{
    for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
    {
        rr::VertexPacket &packet = *(packets[packetNdx]);

        packet.position   = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
        packet.outputs[0] = rr::readVertexAttribFloat(inputs[1], packet.instanceNdx, packet.vertexNdx);
    }
}

void MultiTexShader::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
                                    const rr::FragmentShadingContext &context) const
{
    DE_ASSERT((int)m_unitTypes.size() == m_numUnits);
    DE_ASSERT((int)m_transformations.size() == m_numUnits);
    DE_ASSERT((int)m_lodDerivateParts.size() == m_numUnits);

    for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
    {
        rr::FragmentPacket &packet  = packets[packetNdx];
        const float colorMultiplier = 1.0f / (float)m_numUnits;
        Vec4 outColors[4]           = {Vec4(0.0f), Vec4(0.0f), Vec4(0.0f), Vec4(0.0f)};

        for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++)
        {
            tcu::Vec4 texSamples[4];

            // Read tex coords
            const tcu::Vec2 texCoords[4] = {
                rr::readTriangleVarying<float>(packet, context, 0, 0).xy(),
                rr::readTriangleVarying<float>(packet, context, 0, 1).xy(),
                rr::readTriangleVarying<float>(packet, context, 0, 2).xy(),
                rr::readTriangleVarying<float>(packet, context, 0, 3).xy(),
            };

            // Transform
            tcu::Vec3 coords3D[4] = {
                (m_transformations[unitNdx] * Vec4(texCoords[0].x(), texCoords[0].y(), 1.0f, 1.0f)).xyz(),
                (m_transformations[unitNdx] * Vec4(texCoords[1].x(), texCoords[1].y(), 1.0f, 1.0f)).xyz(),
                (m_transformations[unitNdx] * Vec4(texCoords[2].x(), texCoords[2].y(), 1.0f, 1.0f)).xyz(),
                (m_transformations[unitNdx] * Vec4(texCoords[3].x(), texCoords[3].y(), 1.0f, 1.0f)).xyz(),
            };

            // To 2D
            const tcu::Vec2 coords2D[4] = {
                coords3D[0].xy(),
                coords3D[1].xy(),
                coords3D[2].xy(),
                coords3D[3].xy(),
            };

            // Sample
            switch (m_unitTypes[unitNdx])
            {
            case GL_TEXTURE_2D:
                m_uniforms[4 * unitNdx].sampler.tex2D->sample4(texSamples, coords2D);
                break;
            case GL_TEXTURE_CUBE_MAP:
                m_uniforms[4 * unitNdx].sampler.texCube->sample4(texSamples, coords3D);
                break;
            case GL_TEXTURE_2D_ARRAY:
                m_uniforms[4 * unitNdx].sampler.tex2DArray->sample4(texSamples, coords3D);
                break;
            case GL_TEXTURE_3D:
                m_uniforms[4 * unitNdx].sampler.tex3D->sample4(texSamples, coords3D);
                break;
            default:
                DE_ASSERT(false);
            }

            // Add to sum
            for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
                outColors[fragNdx] +=
                    colorMultiplier * (texSamples[fragNdx] * m_texScales[unitNdx] + m_texBiases[unitNdx]);
        }

        // output
        for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
            rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, outColors[fragNdx]);
    }
}

class TextureUnitCase : public TestCase
{
public:
    enum CaseType
    {
        CASE_ONLY_2D = 0,
        CASE_ONLY_CUBE,
        CASE_ONLY_2D_ARRAY,
        CASE_ONLY_3D,
        CASE_MIXED,

        CASE_LAST
    };
    TextureUnitCase(Context &context, const char *name, const char *desc,
                    int numUnits /* \note If non-positive, use all units */, CaseType caseType, uint32_t randSeed);
    ~TextureUnitCase(void);

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

private:
    struct TextureParameters
    {
        GLenum internalFormat;
        GLenum wrapModeS;
        GLenum wrapModeT;
        GLenum wrapModeR;
        GLenum minFilter;
        GLenum magFilter;
    };

    TextureUnitCase(const TextureUnitCase &other);
    TextureUnitCase &operator=(const TextureUnitCase &other);

    void upload2dTexture(int texNdx, sglr::Context &context);
    void uploadCubeTexture(int texNdx, sglr::Context &context);
    void upload2dArrayTexture(int texNdx, sglr::Context &context);
    void upload3dTexture(int texNdx, sglr::Context &context);

    void render(sglr::Context &context);

    const int m_numUnitsParam;
    const CaseType m_caseType;
    const uint32_t m_randSeed;

    int m_numTextures; //!< \note Needed in addition to m_numUnits since same texture may be bound to many texture units.
    int m_numUnits;    //!< = m_numUnitsParam > 0 ? m_numUnitsParam : implementationDefinedMaximum

    vector<GLenum> m_textureTypes;
    vector<TextureParameters> m_textureParams;
    vector<tcu::Texture2D *> m_textures2d;
    vector<tcu::TextureCube *> m_texturesCube;
    vector<tcu::Texture2DArray *> m_textures2dArray;
    vector<tcu::Texture3D *> m_textures3d;
    vector<int> m_unitTextures; //!< Which texture is used in a particular unit.
    vector<int>
        m_ndxTexType; //!< Index of a texture in m_textures2d, m_texturesCube, m_textures2dArray or m_textures3d, depending on texture type.
    MultiTexShader *m_shader;
};

TextureUnitCase::TextureUnitCase(Context &context, const char *name, const char *desc, int numUnits, CaseType caseType,
                                 uint32_t randSeed)
    : TestCase(context, tcu::NODETYPE_SELF_VALIDATE, name, desc)
    , m_numUnitsParam(numUnits)
    , m_caseType(caseType)
    , m_randSeed(randSeed)
    , m_numTextures(0)
    , m_numUnits(0)
    , m_shader(DE_NULL)
{
}

TextureUnitCase::~TextureUnitCase(void)
{
    TextureUnitCase::deinit();
}

void TextureUnitCase::deinit(void)
{
    for (vector<tcu::Texture2D *>::iterator i = m_textures2d.begin(); i != m_textures2d.end(); i++)
        delete *i;
    m_textures2d.clear();

    for (vector<tcu::TextureCube *>::iterator i = m_texturesCube.begin(); i != m_texturesCube.end(); i++)
        delete *i;
    m_texturesCube.clear();

    for (vector<tcu::Texture2DArray *>::iterator i = m_textures2dArray.begin(); i != m_textures2dArray.end(); i++)
        delete *i;
    m_textures2dArray.clear();

    for (vector<tcu::Texture3D *>::iterator i = m_textures3d.begin(); i != m_textures3d.end(); i++)
        delete *i;
    m_textures3d.clear();

    delete m_shader;
    m_shader = DE_NULL;
}

void TextureUnitCase::init(void)
{
    m_numUnits = m_numUnitsParam > 0 ? m_numUnitsParam : m_context.getContextInfo().getInt(GL_MAX_TEXTURE_IMAGE_UNITS);

    // Make the textures.

    try
    {
        tcu::TestLog &log = m_testCtx.getLog();
        de::Random rnd(m_randSeed);

        if (rnd.getFloat() < 0.7f)
            m_numTextures = m_numUnits; // In most cases use one unit per texture.
        else
            m_numTextures =
                rnd.getInt(deMax32(1, m_numUnits - 2), m_numUnits); // Sometimes assign same texture to multiple units.

        log << tcu::TestLog::Message
            << ("Using " + de::toString(m_numUnits) + " texture unit(s) and " + de::toString(m_numTextures) +
                " texture(s)")
                   .c_str()
            << tcu::TestLog::EndMessage;

        m_textureTypes.reserve(m_numTextures);
        m_textureParams.reserve(m_numTextures);
        m_ndxTexType.reserve(m_numTextures);

        // Generate textures.

        for (int texNdx = 0; texNdx < m_numTextures; texNdx++)
        {
            // Either fixed or randomized target types, and randomized parameters for every texture.

            TextureParameters params;

            DE_STATIC_ASSERT(CASE_ONLY_2D == 0 && CASE_MIXED + 1 == CASE_LAST);

            int texType       = m_caseType == CASE_MIXED ? rnd.getInt(0, (int)CASE_MIXED - 1) : (int)m_caseType;
            bool is2dTex      = texType == 0;
            bool isCubeTex    = texType == 1;
            bool is2dArrayTex = texType == 2;
            bool is3dTex      = texType == 3;

            DE_ASSERT(is2dTex || isCubeTex || is2dArrayTex || is3dTex);

            GLenum type         = is2dTex      ? GL_TEXTURE_2D :
                                  isCubeTex    ? GL_TEXTURE_CUBE_MAP :
                                  is2dArrayTex ? GL_TEXTURE_2D_ARRAY :
                                                 GL_TEXTURE_3D;
            const int texWidth  = is2dTex      ? TEXTURE_WIDTH_2D :
                                  isCubeTex    ? TEXTURE_WIDTH_CUBE :
                                  is2dArrayTex ? TEXTURE_WIDTH_2D_ARRAY :
                                                 TEXTURE_WIDTH_3D;
            const int texHeight = is2dTex      ? TEXTURE_HEIGHT_2D :
                                  isCubeTex    ? TEXTURE_HEIGHT_CUBE :
                                  is2dArrayTex ? TEXTURE_HEIGHT_2D_ARRAY :
                                                 TEXTURE_HEIGHT_3D;

            const int texDepth  = is3dTex ? TEXTURE_DEPTH_3D : 1;
            const int texLayers = is2dArrayTex ? TEXTURE_LAYERS_2D_ARRAY : 1;

            bool mipmaps  = (deIsPowerOfTwo32(texWidth) && deIsPowerOfTwo32(texHeight) && deIsPowerOfTwo32(texDepth));
            int numLevels = mipmaps ? deLog2Floor32(de::max(de::max(texWidth, texHeight), texDepth)) + 1 : 1;

            params.internalFormat =
                s_testSizedInternalFormats[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testSizedInternalFormats) - 1)];

            bool isFilterable = glu::isGLInternalColorFormatFilterable(params.internalFormat);

            params.wrapModeS = s_testWrapModes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testWrapModes) - 1)];
            params.wrapModeT = s_testWrapModes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testWrapModes) - 1)];
            params.wrapModeR = s_testWrapModes[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testWrapModes) - 1)];

            params.magFilter =
                isFilterable ? s_testMagFilters[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testMagFilters) - 1)] : GL_NEAREST;

            if (mipmaps)
                params.minFilter =
                    isFilterable ?
                        s_testMinFilters[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testMinFilters) - 1)] :
                        s_testNearestMinFilters[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testNearestMinFilters) - 1)];
            else
                params.minFilter =
                    isFilterable ?
                        s_testNonMipmapMinFilters[rnd.getInt(0, DE_LENGTH_OF_ARRAY(s_testNonMipmapMinFilters) - 1)] :
                        GL_NEAREST;

            m_textureTypes.push_back(type);
            m_textureParams.push_back(params);

            // Create new texture.

            tcu::TextureFormat texFormat = glu::mapGLInternalFormat((uint32_t)params.internalFormat);

            if (is2dTex)
            {
                m_ndxTexType.push_back(
                    (int)m_textures2d.size()); // Remember the index this texture has in the 2d texture vector.
                m_textures2d.push_back(new tcu::Texture2D(texFormat, texWidth, texHeight));
            }
            else if (isCubeTex)
            {
                m_ndxTexType.push_back(
                    (int)m_texturesCube.size()); // Remember the index this texture has in the cube texture vector.
                DE_ASSERT(texWidth == texHeight);
                m_texturesCube.push_back(new tcu::TextureCube(texFormat, texWidth));
            }
            else if (is2dArrayTex)
            {
                m_ndxTexType.push_back(
                    (int)m_textures2dArray
                        .size()); // Remember the index this texture has in the 2d array texture vector.
                m_textures2dArray.push_back(new tcu::Texture2DArray(texFormat, texWidth, texHeight, texLayers));
            }
            else
            {
                m_ndxTexType.push_back(
                    (int)m_textures3d.size()); // Remember the index this texture has in the 3d vector.
                m_textures3d.push_back(new tcu::Texture3D(texFormat, texWidth, texHeight, texDepth));
            }

            tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(texFormat);
            Vec4 cBias                     = fmtInfo.valueMin;
            Vec4 cScale                    = fmtInfo.valueMax - fmtInfo.valueMin;

            // Fill with grid texture.

            int numFaces = isCubeTex ? (int)tcu::CUBEFACE_LAST : 1;

            for (int face = 0; face < numFaces; face++)
            {
                uint32_t rgb   = rnd.getUint32() & 0x00ffffff;
                uint32_t alpha = 0xff000000;

                uint32_t colorA = alpha | rgb;
                uint32_t colorB = alpha | ((~rgb) & 0x00ffffff);

                for (int levelNdx = 0; levelNdx < numLevels; levelNdx++)
                {
                    if (is2dTex)
                        m_textures2d.back()->allocLevel(levelNdx);
                    else if (isCubeTex)
                        m_texturesCube.back()->allocLevel((tcu::CubeFace)face, levelNdx);
                    else if (is2dArrayTex)
                        m_textures2dArray.back()->allocLevel(levelNdx);
                    else
                        m_textures3d.back()->allocLevel(levelNdx);

                    int curCellSize = deMax32(1, GRID_CELL_SIZE >> levelNdx); // \note Scale grid cell size for mipmaps.

                    tcu::PixelBufferAccess access =
                        is2dTex      ? m_textures2d.back()->getLevel(levelNdx) :
                        isCubeTex    ? m_texturesCube.back()->getLevelFace(levelNdx, (tcu::CubeFace)face) :
                        is2dArrayTex ? m_textures2dArray.back()->getLevel(levelNdx) :
                                       m_textures3d.back()->getLevel(levelNdx);

                    tcu::fillWithGrid(access, curCellSize, tcu::RGBA(colorA).toVec() * cScale + cBias,
                                      tcu::RGBA(colorB).toVec() * cScale + cBias);
                }
            }
        }

        // Assign a texture index to each unit.

        m_unitTextures.reserve(m_numUnits);

        // \note Every texture is used at least once.
        for (int i = 0; i < m_numTextures; i++)
            m_unitTextures.push_back(i);

        // Assign a random texture to remaining units.
        while ((int)m_unitTextures.size() < m_numUnits)
            m_unitTextures.push_back(rnd.getInt(0, m_numTextures - 1));

        rnd.shuffle(m_unitTextures.begin(), m_unitTextures.end());

        // Generate information for shader.

        vector<GLenum> unitTypes;
        vector<Vec4> texScales;
        vector<Vec4> texBiases;
        vector<glu::DataType> samplerTypes;
        vector<int> num2dArrayLayers;

        unitTypes.reserve(m_numUnits);
        texScales.reserve(m_numUnits);
        texBiases.reserve(m_numUnits);
        samplerTypes.reserve(m_numUnits);
        num2dArrayLayers.reserve(m_numUnits);

        for (int i = 0; i < m_numUnits; i++)
        {
            int texNdx                     = m_unitTextures[i];
            GLenum type                    = m_textureTypes[texNdx];
            tcu::TextureFormat fmt         = glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat);
            tcu::TextureFormatInfo fmtInfo = tcu::getTextureFormatInfo(fmt);

            unitTypes.push_back(type);

            if (type == GL_TEXTURE_2D_ARRAY)
                num2dArrayLayers.push_back(m_textures2dArray[m_ndxTexType[texNdx]]->getNumLayers());

            texScales.push_back(fmtInfo.lookupScale);
            texBiases.push_back(fmtInfo.lookupBias);

            switch (type)
            {
            case GL_TEXTURE_2D:
                samplerTypes.push_back(glu::getSampler2DType(fmt));
                break;
            case GL_TEXTURE_CUBE_MAP:
                samplerTypes.push_back(glu::getSamplerCubeType(fmt));
                break;
            case GL_TEXTURE_2D_ARRAY:
                samplerTypes.push_back(glu::getSampler2DArrayType(fmt));
                break;
            case GL_TEXTURE_3D:
                samplerTypes.push_back(glu::getSampler3DType(fmt));
                break;
            default:
                DE_ASSERT(false);
            }
        }

        // Create shader.

        DE_ASSERT(m_shader == DE_NULL);
        m_shader = new MultiTexShader(rnd.getUint32(), m_numUnits, unitTypes, samplerTypes, texScales, texBiases,
                                      num2dArrayLayers);
    }
    catch (const std::exception &)
    {
        // Clean up to save memory.
        TextureUnitCase::deinit();
        throw;
    }
}

TextureUnitCase::IterateResult TextureUnitCase::iterate(void)
{
    glu::RenderContext &renderCtx         = m_context.getRenderContext();
    const tcu::RenderTarget &renderTarget = renderCtx.getRenderTarget();
    tcu::TestLog &log                     = m_testCtx.getLog();
    de::Random rnd(m_randSeed);

    int viewportWidth  = deMin32(VIEWPORT_WIDTH, renderTarget.getWidth());
    int viewportHeight = deMin32(VIEWPORT_HEIGHT, renderTarget.getHeight());
    int viewportX      = rnd.getInt(0, renderTarget.getWidth() - viewportWidth);
    int viewportY      = rnd.getInt(0, renderTarget.getHeight() - viewportHeight);

    tcu::Surface gles3Frame(viewportWidth, viewportHeight);
    tcu::Surface refFrame(viewportWidth, viewportHeight);

    {
        // First we do some tricks to make the LODs safer wrt. precision issues. See MultiTexShader::makeSafeLods().

        vector<IVec3> texSizes;
        texSizes.reserve(m_numUnits);

        for (int i = 0; i < m_numUnits; i++)
        {
            int texNdx       = m_unitTextures[i];
            int texNdxInType = m_ndxTexType[texNdx];
            GLenum type      = m_textureTypes[texNdx];

            switch (type)
            {
            case GL_TEXTURE_2D:
                texSizes.push_back(
                    IVec3(m_textures2d[texNdxInType]->getWidth(), m_textures2d[texNdxInType]->getHeight(), 0));
                break;
            case GL_TEXTURE_CUBE_MAP:
                texSizes.push_back(
                    IVec3(m_texturesCube[texNdxInType]->getSize(), m_texturesCube[texNdxInType]->getSize(), 0));
                break;
            case GL_TEXTURE_2D_ARRAY:
                texSizes.push_back(IVec3(m_textures2dArray[texNdxInType]->getWidth(),
                                         m_textures2dArray[texNdxInType]->getHeight(), 0));
                break;
            case GL_TEXTURE_3D:
                texSizes.push_back(IVec3(m_textures3d[texNdxInType]->getWidth(),
                                         m_textures3d[texNdxInType]->getHeight(),
                                         m_textures3d[texNdxInType]->getDepth()));
                break;
            default:
                DE_ASSERT(false);
            }
        }

        m_shader->makeSafeLods(texSizes, IVec2(viewportWidth, viewportHeight));
    }

    // Render using GLES3.
    {
        sglr::GLContext context(renderCtx, log, sglr::GLCONTEXT_LOG_CALLS | sglr::GLCONTEXT_LOG_PROGRAMS,
                                tcu::IVec4(viewportX, viewportY, viewportWidth, viewportHeight));

        render(context);

        context.readPixels(gles3Frame, 0, 0, viewportWidth, viewportHeight);
    }

    // Render reference image.
    {
        sglr::ReferenceContextBuffers buffers(
            tcu::PixelFormat(8, 8, 8, renderTarget.getPixelFormat().alphaBits ? 8 : 0), 0 /* depth */, 0 /* stencil */,
            viewportWidth, viewportHeight);
        sglr::ReferenceContext context(sglr::ReferenceContextLimits(renderCtx), buffers.getColorbuffer(),
                                       buffers.getDepthbuffer(), buffers.getStencilbuffer());

        render(context);

        context.readPixels(refFrame, 0, 0, viewportWidth, viewportHeight);
    }

    // Compare images.
    const float threshold = 0.001f;
    bool isOk = tcu::fuzzyCompare(log, "ComparisonResult", "Image comparison result", refFrame, gles3Frame, threshold,
                                  tcu::COMPARE_LOG_RESULT);

    // Store test result.
    m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                            isOk ? "Pass" : "Image comparison failed");

    return STOP;
}

void TextureUnitCase::upload2dTexture(int texNdx, sglr::Context &context)
{
    int ndx2d                     = m_ndxTexType[texNdx];
    const tcu::Texture2D *texture = m_textures2d[ndx2d];
    glu::TransferFormat formatGl =
        glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat));

    context.pixelStorei(GL_UNPACK_ALIGNMENT, 1);

    for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++)
    {
        if (texture->isLevelEmpty(levelNdx))
            continue;

        tcu::ConstPixelBufferAccess access = texture->getLevel(levelNdx);
        int width                          = access.getWidth();
        int height                         = access.getHeight();

        DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * width);

        context.texImage2D(GL_TEXTURE_2D, levelNdx, m_textureParams[texNdx].internalFormat, width, height,
                           0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr());
        GLU_EXPECT_NO_ERROR(context.getError(), "Set 2d texture image data");
    }
}

void TextureUnitCase::uploadCubeTexture(int texNdx, sglr::Context &context)
{
    int ndxCube                     = m_ndxTexType[texNdx];
    const tcu::TextureCube *texture = m_texturesCube[ndxCube];
    glu::TransferFormat formatGl =
        glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat));

    context.pixelStorei(GL_UNPACK_ALIGNMENT, 1);

    for (int face = 0; face < (int)tcu::CUBEFACE_LAST; face++)
    {
        for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++)
        {
            if (texture->isLevelEmpty((tcu::CubeFace)face, levelNdx))
                continue;

            tcu::ConstPixelBufferAccess access = texture->getLevelFace(levelNdx, (tcu::CubeFace)face);
            int width                          = access.getWidth();
            int height                         = access.getHeight();

            DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * width);

            context.texImage2D(s_cubeFaceTargets[face], levelNdx, m_textureParams[texNdx].internalFormat, width, height,
                               0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr());
            GLU_EXPECT_NO_ERROR(context.getError(), "Set cube map image data");
        }
    }
}

void TextureUnitCase::upload2dArrayTexture(int texNdx, sglr::Context &context)
{
    int ndx2dArray                     = m_ndxTexType[texNdx];
    const tcu::Texture2DArray *texture = m_textures2dArray[ndx2dArray];
    glu::TransferFormat formatGl =
        glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat));

    context.pixelStorei(GL_UNPACK_ALIGNMENT, 1);

    for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++)
    {
        if (texture->isLevelEmpty(levelNdx))
            continue;

        tcu::ConstPixelBufferAccess access = texture->getLevel(levelNdx);
        int width                          = access.getWidth();
        int height                         = access.getHeight();
        int layers                         = access.getDepth();

        DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * width);
        DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize() * width * height);

        context.texImage3D(GL_TEXTURE_2D_ARRAY, levelNdx, m_textureParams[texNdx].internalFormat, width, height, layers,
                           0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr());
        GLU_EXPECT_NO_ERROR(context.getError(), "Set 2d array texture image data");
    }
}

void TextureUnitCase::upload3dTexture(int texNdx, sglr::Context &context)
{
    int ndx3d                     = m_ndxTexType[texNdx];
    const tcu::Texture3D *texture = m_textures3d[ndx3d];
    glu::TransferFormat formatGl =
        glu::getTransferFormat(glu::mapGLInternalFormat(m_textureParams[texNdx].internalFormat));

    context.pixelStorei(GL_UNPACK_ALIGNMENT, 1);

    for (int levelNdx = 0; levelNdx < texture->getNumLevels(); levelNdx++)
    {
        if (texture->isLevelEmpty(levelNdx))
            continue;

        tcu::ConstPixelBufferAccess access = texture->getLevel(levelNdx);
        int width                          = access.getWidth();
        int height                         = access.getHeight();
        int depth                          = access.getDepth();

        DE_ASSERT(access.getRowPitch() == access.getFormat().getPixelSize() * width);
        DE_ASSERT(access.getSlicePitch() == access.getFormat().getPixelSize() * width * height);

        context.texImage3D(GL_TEXTURE_3D, levelNdx, m_textureParams[texNdx].internalFormat, width, height, depth,
                           0 /* border */, formatGl.format, formatGl.dataType, access.getDataPtr());
        GLU_EXPECT_NO_ERROR(context.getError(), "Set 3d texture image data");
    }
}

void TextureUnitCase::render(sglr::Context &context)
{
    // Setup textures.

    vector<uint32_t> textureGLNames;
    vector<bool> isTextureSetUp(
        m_numTextures,
        false); // \note Same texture may be bound to multiple units, but we only want to set up parameters and data once per texture.

    textureGLNames.resize(m_numTextures);
    context.genTextures(m_numTextures, &textureGLNames[0]);
    GLU_EXPECT_NO_ERROR(context.getError(), "Generate textures");

    for (int unitNdx = 0; unitNdx < m_numUnits; unitNdx++)
    {
        int texNdx = m_unitTextures[unitNdx];

        // Bind texture to unit.
        context.activeTexture(GL_TEXTURE0 + unitNdx);
        GLU_EXPECT_NO_ERROR(context.getError(), "Set active texture");
        context.bindTexture(m_textureTypes[texNdx], textureGLNames[texNdx]);
        GLU_EXPECT_NO_ERROR(context.getError(), "Bind texture");

        if (!isTextureSetUp[texNdx])
        {
            // Binding this texture for first time, so set parameters and data.

            context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_WRAP_S, m_textureParams[texNdx].wrapModeS);
            context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_WRAP_T, m_textureParams[texNdx].wrapModeT);
            if (m_textureTypes[texNdx] == GL_TEXTURE_3D)
                context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_WRAP_R, m_textureParams[texNdx].wrapModeR);
            context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_MIN_FILTER, m_textureParams[texNdx].minFilter);
            context.texParameteri(m_textureTypes[texNdx], GL_TEXTURE_MAG_FILTER, m_textureParams[texNdx].magFilter);
            GLU_EXPECT_NO_ERROR(context.getError(), "Set texture parameters");

            switch (m_textureTypes[texNdx])
            {
            case GL_TEXTURE_2D:
                upload2dTexture(texNdx, context);
                break;
            case GL_TEXTURE_CUBE_MAP:
                uploadCubeTexture(texNdx, context);
                break;
            case GL_TEXTURE_2D_ARRAY:
                upload2dArrayTexture(texNdx, context);
                break;
            case GL_TEXTURE_3D:
                upload3dTexture(texNdx, context);
                break;
            default:
                DE_ASSERT(false);
            }

            isTextureSetUp[texNdx] = true; // Don't set up this texture's parameters and data again later.
        }
    }

    GLU_EXPECT_NO_ERROR(context.getError(), "Set textures");

    // Setup shader

    uint32_t shaderID = context.createProgram(m_shader);

    // Draw.

    context.clearColor(0.125f, 0.25f, 0.5f, 1.0f);
    context.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
    m_shader->setUniforms(context, shaderID);
    sglr::drawQuad(context, shaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
    GLU_EXPECT_NO_ERROR(context.getError(), "Draw");

    // Delete previously generated texture names.

    context.deleteTextures(m_numTextures, &textureGLNames[0]);
    GLU_EXPECT_NO_ERROR(context.getError(), "Delete textures");
}

TextureUnitTests::TextureUnitTests(Context &context) : TestCaseGroup(context, "units", "Texture Unit Usage Tests")
{
}

TextureUnitTests::~TextureUnitTests(void)
{
}

void TextureUnitTests::init(void)
{
    const int numTestsPerGroup = 10;

    static const int unitCounts[] = {
        2, 4, 8,
        -1 // \note Negative stands for the implementation-specified maximum.
    };

    for (int unitCountNdx = 0; unitCountNdx < DE_LENGTH_OF_ARRAY(unitCounts); unitCountNdx++)
    {
        int numUnits = unitCounts[unitCountNdx];

        string countGroupName = (unitCounts[unitCountNdx] < 0 ? "all" : de::toString(numUnits)) + "_units";

        tcu::TestCaseGroup *countGroup = new tcu::TestCaseGroup(m_testCtx, countGroupName.c_str(), "");
        addChild(countGroup);

        DE_STATIC_ASSERT((int)TextureUnitCase::CASE_ONLY_2D == 0);

        for (int caseType = (int)TextureUnitCase::CASE_ONLY_2D; caseType < (int)TextureUnitCase::CASE_LAST; caseType++)
        {
            const char *caseTypeGroupName =
                (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_2D       ? "only_2d" :
                (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_CUBE     ? "only_cube" :
                (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_2D_ARRAY ? "only_2d_array" :
                (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_ONLY_3D       ? "only_3d" :
                (TextureUnitCase::CaseType)caseType == TextureUnitCase::CASE_MIXED         ? "mixed" :
                                                                                             DE_NULL;

            DE_ASSERT(caseTypeGroupName != DE_NULL);

            tcu::TestCaseGroup *caseTypeGroup = new tcu::TestCaseGroup(m_testCtx, caseTypeGroupName, "");
            countGroup->addChild(caseTypeGroup);

            for (int testNdx = 0; testNdx < numTestsPerGroup; testNdx++)
                caseTypeGroup->addChild(new TextureUnitCase(m_context, de::toString(testNdx).c_str(), "", numUnits,
                                                            (TextureUnitCase::CaseType)caseType,
                                                            deUint32Hash((uint32_t)testNdx)));
        }
    }
}

} // namespace Functional
} // namespace gles3
} // namespace deqp