/*-------------------------------------------------------------------------
 * 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 Shader built-in variable tests.
 *//*--------------------------------------------------------------------*/

#include "es3fShaderBuiltinVarTests.hpp"
#include "glsShaderRenderCase.hpp"
#include "glsShaderExecUtil.hpp"
#include "deRandom.hpp"
#include "deString.h"
#include "deMath.h"
#include "deUniquePtr.hpp"
#include "deStringUtil.hpp"
#include "tcuTestLog.hpp"
#include "tcuTestCase.hpp"
#include "tcuTextureUtil.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuImageCompare.hpp"
#include "gluPixelTransfer.hpp"
#include "gluDrawUtil.hpp"
#include "gluStrUtil.hpp"
#include "rrRenderer.hpp"
#include "rrFragmentOperations.hpp"

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

using std::string;
using std::vector;
using tcu::TestLog;

namespace deqp
{
namespace gles3
{
namespace Functional
{

static int getInteger(const glw::Functions &gl, uint32_t pname)
{
    int value = -1;
    gl.getIntegerv(pname, &value);
    GLU_EXPECT_NO_ERROR(gl.getError(),
                        ("glGetIntegerv(" + glu::getGettableStateStr((int)pname).toString() + ")").c_str());
    return value;
}

template <uint32_t Pname>
static int getInteger(const glw::Functions &gl)
{
    return getInteger(gl, Pname);
}

static int getVectorsFromComps(const glw::Functions &gl, uint32_t pname)
{
    int value = -1;
    gl.getIntegerv(pname, &value);
    GLU_EXPECT_NO_ERROR(gl.getError(),
                        ("glGetIntegerv(" + glu::getGettableStateStr((int)pname).toString() + ")").c_str());
    // Accept truncated division. According to the spec, the number of vectors is number of components divided by four, plain and simple.
    return value / 4;
}

template <uint32_t Pname>
static int getVectorsFromComps(const glw::Functions &gl)
{
    return getVectorsFromComps(gl, Pname);
}

class ShaderBuiltinConstantCase : public TestCase
{
public:
    typedef int (*GetConstantValueFunc)(const glw::Functions &gl);

    ShaderBuiltinConstantCase(Context &context, const char *name, const char *desc, const char *varName,
                              GetConstantValueFunc getValue, glu::ShaderType shaderType);
    ~ShaderBuiltinConstantCase(void);

    IterateResult iterate(void);

private:
    const std::string m_varName;
    const GetConstantValueFunc m_getValue;
    const glu::ShaderType m_shaderType;
};

ShaderBuiltinConstantCase::ShaderBuiltinConstantCase(Context &context, const char *name, const char *desc,
                                                     const char *varName, GetConstantValueFunc getValue,
                                                     glu::ShaderType shaderType)
    : TestCase(context, name, desc)
    , m_varName(varName)
    , m_getValue(getValue)
    , m_shaderType(shaderType)
{
}

ShaderBuiltinConstantCase::~ShaderBuiltinConstantCase(void)
{
}

static gls::ShaderExecUtil::ShaderExecutor *createGetConstantExecutor(const glu::RenderContext &renderCtx,
                                                                      glu::ShaderType shaderType,
                                                                      const std::string &varName)
{
    using namespace gls::ShaderExecUtil;

    ShaderSpec shaderSpec;

    shaderSpec.version = glu::GLSL_VERSION_300_ES;
    shaderSpec.source  = string("result = ") + varName + ";\n";
    shaderSpec.outputs.push_back(Symbol("result", glu::VarType(glu::TYPE_INT, glu::PRECISION_HIGHP)));

    return createExecutor(renderCtx, shaderType, shaderSpec);
}

ShaderBuiltinConstantCase::IterateResult ShaderBuiltinConstantCase::iterate(void)
{
    using namespace gls::ShaderExecUtil;

    const de::UniquePtr<ShaderExecutor> shaderExecutor(
        createGetConstantExecutor(m_context.getRenderContext(), m_shaderType, m_varName));
    const int reference = m_getValue(m_context.getRenderContext().getFunctions());
    int result          = -1;
    void *const outputs = &result;

    if (!shaderExecutor->isOk())
    {
        shaderExecutor->log(m_testCtx.getLog());
        TCU_FAIL("Compile failed");
    }

    shaderExecutor->useProgram();
    shaderExecutor->execute(1, DE_NULL, &outputs);

    m_testCtx.getLog() << TestLog::Integer(m_varName, m_varName, "", QP_KEY_TAG_NONE, result);

    if (result != reference)
    {
        m_testCtx.getLog() << TestLog::Message << "ERROR: Expected " << m_varName << " = " << reference
                           << TestLog::EndMessage << TestLog::Message << "Test shader:" << TestLog::EndMessage;
        shaderExecutor->log(m_testCtx.getLog());
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Invalid builtin constant value");
    }
    else
        m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");

    return STOP;
}

namespace
{

struct DepthRangeParams
{
    DepthRangeParams(void) : zNear(0.0f), zFar(1.0f)
    {
    }

    DepthRangeParams(float zNear_, float zFar_) : zNear(zNear_), zFar(zFar_)
    {
    }

    float zNear;
    float zFar;
};

class DepthRangeEvaluator : public gls::ShaderEvaluator
{
public:
    DepthRangeEvaluator(const DepthRangeParams &params) : m_params(params)
    {
    }

    void evaluate(gls::ShaderEvalContext &c)
    {
        float zNear   = deFloatClamp(m_params.zNear, 0.0f, 1.0f);
        float zFar    = deFloatClamp(m_params.zFar, 0.0f, 1.0f);
        float diff    = zFar - zNear;
        c.color.xyz() = tcu::Vec3(zNear, zFar, diff * 0.5f + 0.5f);
    }

private:
    const DepthRangeParams &m_params;
};

} // namespace

class ShaderDepthRangeTest : public gls::ShaderRenderCase
{
public:
    ShaderDepthRangeTest(Context &context, const char *name, const char *desc, bool isVertexCase)
        : ShaderRenderCase(context.getTestContext(), context.getRenderContext(), context.getContextInfo(), name, desc,
                           isVertexCase, m_evaluator)
        , m_evaluator(m_depthRange)
        , m_iterNdx(0)
    {
    }

    void init(void)
    {
        static const char *defaultVertSrc = "#version 300 es\n"
                                            "in highp vec4 a_position;\n"
                                            "void main (void)\n"
                                            "{\n"
                                            "    gl_Position = a_position;\n"
                                            "}\n";
        static const char *defaultFragSrc = "#version 300 es\n"
                                            "in mediump vec4 v_color;\n"
                                            "layout(location = 0) out mediump vec4 o_color;\n\n"
                                            "void main (void)\n"
                                            "{\n"
                                            "    o_color = v_color;\n"
                                            "}\n";

        // Construct shader.
        std::ostringstream src;
        src << "#version 300 es\n";
        if (m_isVertexCase)
            src << "in highp vec4 a_position;\n"
                << "out mediump vec4 v_color;\n";
        else
            src << "layout(location = 0) out mediump vec4 o_color;\n";

        src << "void main (void)\n{\n";
        src << "\t" << (m_isVertexCase ? "v_color" : "o_color")
            << " = vec4(gl_DepthRange.near, gl_DepthRange.far, gl_DepthRange.diff*0.5 + 0.5, 1.0);\n";

        if (m_isVertexCase)
            src << "\tgl_Position = a_position;\n";

        src << "}\n";

        m_vertShaderSource = m_isVertexCase ? src.str() : defaultVertSrc;
        m_fragShaderSource = m_isVertexCase ? defaultFragSrc : src.str();

        gls::ShaderRenderCase::init();
    }

    IterateResult iterate(void)
    {
        const glw::Functions &gl = m_renderCtx.getFunctions();

        const DepthRangeParams cases[] = {DepthRangeParams(0.0f, 1.0f), DepthRangeParams(1.5f, -1.0f),
                                          DepthRangeParams(0.7f, 0.3f)};

        m_depthRange = cases[m_iterNdx];
        m_testCtx.getLog() << tcu::TestLog::Message << "glDepthRangef(" << m_depthRange.zNear << ", "
                           << m_depthRange.zFar << ")" << tcu::TestLog::EndMessage;
        gl.depthRangef(m_depthRange.zNear, m_depthRange.zFar);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glDepthRangef()");

        gls::ShaderRenderCase::iterate();
        m_iterNdx += 1;

        if (m_iterNdx == DE_LENGTH_OF_ARRAY(cases) || m_testCtx.getTestResult() != QP_TEST_RESULT_PASS)
            return STOP;
        else
            return CONTINUE;
    }

private:
    DepthRangeParams m_depthRange;
    DepthRangeEvaluator m_evaluator;
    int m_iterNdx;
};

class FragCoordXYZCase : public TestCase
{
public:
    FragCoordXYZCase(Context &context) : TestCase(context, "fragcoord_xyz", "gl_FragCoord.xyz Test")
    {
    }

    IterateResult iterate(void)
    {
        TestLog &log             = m_testCtx.getLog();
        const glw::Functions &gl = m_context.getRenderContext().getFunctions();
        const int width          = m_context.getRenderTarget().getWidth();
        const int height         = m_context.getRenderTarget().getHeight();
        const tcu::RGBA threshold =
            tcu::RGBA(1, 1, 1, 1) + m_context.getRenderTarget().getPixelFormat().getColorThreshold();
        const tcu::Vec3 scale(1.f / float(width), 1.f / float(height), 1.0f);

        tcu::Surface testImg(width, height);
        tcu::Surface refImg(width, height);

        const glu::ShaderProgram program(m_context.getRenderContext(),
                                         glu::makeVtxFragSources("#version 300 es\n"
                                                                 "in highp vec4 a_position;\n"
                                                                 "void main (void)\n"
                                                                 "{\n"
                                                                 "    gl_Position = a_position;\n"
                                                                 "}\n",

                                                                 "#version 300 es\n"
                                                                 "uniform highp vec3 u_scale;\n"
                                                                 "layout(location = 0) out mediump vec4 o_color;\n"
                                                                 "void main (void)\n"
                                                                 "{\n"
                                                                 "    o_color = vec4(gl_FragCoord.xyz*u_scale, 1.0);\n"
                                                                 "}\n"));

        log << program;

        if (!program.isOk())
            throw tcu::TestError("Compile failed");

        // Draw with GL.
        {
            const float positions[]  = {-1.0f, 1.0f, -1.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f,
                                        1.0f,  1.0f, 0.0f,  1.0f, 1.0f,  -1.0f, 1.0f, 1.0f};
            const uint16_t indices[] = {0, 1, 2, 2, 1, 3};

            const int scaleLoc                 = gl.getUniformLocation(program.getProgram(), "u_scale");
            glu::VertexArrayBinding posBinding = glu::va::Float("a_position", 4, 4, 0, &positions[0]);

            gl.useProgram(program.getProgram());
            gl.uniform3fv(scaleLoc, 1, scale.getPtr());

            glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding,
                      glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));

            glu::readPixels(m_context.getRenderContext(), 0, 0, testImg.getAccess());
            GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
        }

        // Draw reference
        for (int y = 0; y < refImg.getHeight(); y++)
        {
            for (int x = 0; x < refImg.getWidth(); x++)
            {
                const float xf = (float(x) + .5f) / float(refImg.getWidth());
                const float yf = (float(refImg.getHeight() - y - 1) + .5f) / float(refImg.getHeight());
                const float z  = (xf + yf) / 2.0f;
                const tcu::Vec3 fragCoord(float(x) + .5f, float(y) + .5f, z);
                const tcu::Vec3 scaledFC = fragCoord * scale;
                const tcu::Vec4 color(scaledFC.x(), scaledFC.y(), scaledFC.z(), 1.0f);

                refImg.setPixel(x, y, tcu::RGBA(color));
            }
        }

        // Compare
        {
            bool isOk = tcu::pixelThresholdCompare(log, "Result", "Image comparison result", refImg, testImg, threshold,
                                                   tcu::COMPARE_LOG_RESULT);
            m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    isOk ? "Pass" : "Image comparison failed");
        }

        return STOP;
    }
};

static inline float projectedTriInterpolate(const tcu::Vec3 &s, const tcu::Vec3 &w, float nx, float ny)
{
    return (s[0] * (1.0f - nx - ny) / w[0] + s[1] * ny / w[1] + s[2] * nx / w[2]) /
           ((1.0f - nx - ny) / w[0] + ny / w[1] + nx / w[2]);
}

class FragCoordWCase : public TestCase
{
public:
    FragCoordWCase(Context &context) : TestCase(context, "fragcoord_w", "gl_FragCoord.w Test")
    {
    }

    IterateResult iterate(void)
    {
        TestLog &log             = m_testCtx.getLog();
        const glw::Functions &gl = m_context.getRenderContext().getFunctions();
        const int width          = m_context.getRenderTarget().getWidth();
        const int height         = m_context.getRenderTarget().getHeight();
        const tcu::RGBA threshold =
            tcu::RGBA(1, 1, 1, 1) + m_context.getRenderTarget().getPixelFormat().getColorThreshold();

        tcu::Surface testImg(width, height);
        tcu::Surface refImg(width, height);

        const float w[4] = {1.7f, 2.0f, 1.2f, 1.0f};

        const glu::ShaderProgram program(
            m_context.getRenderContext(),
            glu::makeVtxFragSources("#version 300 es\n"
                                    "in highp vec4 a_position;\n"
                                    "void main (void)\n"
                                    "{\n"
                                    "    gl_Position = a_position;\n"
                                    "}\n",

                                    "#version 300 es\n"
                                    "layout(location = 0) out mediump vec4 o_color;\n"
                                    "void main (void)\n"
                                    "{\n"
                                    "    o_color = vec4(0.0, 1.0/gl_FragCoord.w - 1.0, 0.0, 1.0);\n"
                                    "}\n"));

        log << program;

        if (!program.isOk())
            throw tcu::TestError("Compile failed");

        // Draw with GL.
        {
            const float positions[]  = {-w[0], w[0], 0.0f, w[0], -w[1], -w[1], 0.0f, w[1],
                                        w[2],  w[2], 0.0f, w[2], w[3],  -w[3], 0.0f, w[3]};
            const uint16_t indices[] = {0, 1, 2, 2, 1, 3};

            glu::VertexArrayBinding posBinding = glu::va::Float("a_position", 4, 4, 0, &positions[0]);

            gl.useProgram(program.getProgram());

            glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding,
                      glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indices), &indices[0]));

            glu::readPixels(m_context.getRenderContext(), 0, 0, testImg.getAccess());
            GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
        }

        // Draw reference
        for (int y = 0; y < refImg.getHeight(); y++)
        {
            for (int x = 0; x < refImg.getWidth(); x++)
            {
                const float xf = (float(x) + .5f) / float(refImg.getWidth());
                const float yf = (float(refImg.getHeight() - y - 1) + .5f) / float(refImg.getHeight());
                const float oow =
                    ((xf + yf) < 1.0f) ?
                        projectedTriInterpolate(tcu::Vec3(w[0], w[1], w[2]), tcu::Vec3(w[0], w[1], w[2]), xf, yf) :
                        projectedTriInterpolate(tcu::Vec3(w[3], w[2], w[1]), tcu::Vec3(w[3], w[2], w[1]), 1.0f - xf,
                                                1.0f - yf);
                const tcu::Vec4 color(0.0f, oow - 1.0f, 0.0f, 1.0f);

                refImg.setPixel(x, y, tcu::RGBA(color));
            }
        }

        // Compare
        {
            bool isOk = tcu::pixelThresholdCompare(log, "Result", "Image comparison result", refImg, testImg, threshold,
                                                   tcu::COMPARE_LOG_RESULT);
            m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    isOk ? "Pass" : "Image comparison failed");
        }

        return STOP;
    }
};

class PointCoordCase : public TestCase
{
public:
    PointCoordCase(Context &context) : TestCase(context, "pointcoord", "gl_PointCoord Test")
    {
    }

    IterateResult iterate(void)
    {
        TestLog &log             = m_testCtx.getLog();
        const glw::Functions &gl = m_context.getRenderContext().getFunctions();
        const int width          = de::min(256, m_context.getRenderTarget().getWidth());
        const int height         = de::min(256, m_context.getRenderTarget().getHeight());
        const float threshold    = 0.02f;

        const int numPoints = 8;

        vector<tcu::Vec3> coords(numPoints);
        float pointSizeRange[2] = {0.0f, 0.0f};

        de::Random rnd(0x145fa);
        tcu::Surface testImg(width, height);
        tcu::Surface refImg(width, height);

        gl.getFloatv(GL_ALIASED_POINT_SIZE_RANGE, &pointSizeRange[0]);
        GLU_EXPECT_NO_ERROR(gl.getError(), "glGetFloatv(GL_ALIASED_POINT_SIZE_RANGE)");

        if (pointSizeRange[0] <= 0.0f || pointSizeRange[1] <= 0.0f || pointSizeRange[1] < pointSizeRange[0])
            throw tcu::TestError("Invalid GL_ALIASED_POINT_SIZE_RANGE");

        // Compute coordinates.
        {

            for (vector<tcu::Vec3>::iterator coord = coords.begin(); coord != coords.end(); ++coord)
            {
                coord->x() = rnd.getFloat(-0.9f, 0.9f);
                coord->y() = rnd.getFloat(-0.9f, 0.9f);
                coord->z() = rnd.getFloat(pointSizeRange[0], pointSizeRange[1]);
            }
        }

        const glu::ShaderProgram program(
            m_context.getRenderContext(),
            glu::makeVtxFragSources("#version 300 es\n"
                                    "in highp vec3 a_positionSize;\n"
                                    "void main (void)\n"
                                    "{\n"
                                    "    gl_Position = vec4(a_positionSize.xy, 0.0, 1.0);\n"
                                    "    gl_PointSize = a_positionSize.z;\n"
                                    "}\n",

                                    "#version 300 es\n"
                                    "layout(location = 0) out mediump vec4 o_color;\n"
                                    "void main (void)\n"
                                    "{\n"
                                    "    o_color = vec4(gl_PointCoord, 0.0, 1.0);\n"
                                    "}\n"));

        log << program;

        if (!program.isOk())
            throw tcu::TestError("Compile failed");

        // Draw with GL.
        {
            glu::VertexArrayBinding posBinding =
                glu::va::Float("a_positionSize", 3, (int)coords.size(), 0, (const float *)&coords[0]);
            const int viewportX = rnd.getInt(0, m_context.getRenderTarget().getWidth() - width);
            const int viewportY = rnd.getInt(0, m_context.getRenderTarget().getHeight() - height);

            gl.viewport(viewportX, viewportY, width, height);
            gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
            gl.clear(GL_COLOR_BUFFER_BIT);

            gl.useProgram(program.getProgram());

            glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding,
                      glu::pr::Points((int)coords.size()));

            glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess());
            GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
        }

        // Draw reference
        tcu::clear(refImg.getAccess(), tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f));
        for (vector<tcu::Vec3>::const_iterator pointIter = coords.begin(); pointIter != coords.end(); ++pointIter)
        {
            const int x0 = deRoundFloatToInt32(float(width) * (pointIter->x() * 0.5f + 0.5f) - pointIter->z() * 0.5f);
            const int y0 = deRoundFloatToInt32(float(height) * (pointIter->y() * 0.5f + 0.5f) - pointIter->z() * 0.5f);
            const int x1 = deRoundFloatToInt32(float(width) * (pointIter->x() * 0.5f + 0.5f) + pointIter->z() * 0.5f);
            const int y1 = deRoundFloatToInt32(float(height) * (pointIter->y() * 0.5f + 0.5f) + pointIter->z() * 0.5f);
            const int w  = x1 - x0;
            const int h  = y1 - y0;

            for (int yo = 0; yo < h; yo++)
            {
                for (int xo = 0; xo < w; xo++)
                {
                    const float xf = (float(xo) + 0.5f) / float(w);
                    const float yf = (float(h - yo - 1) + 0.5f) / float(h);
                    const tcu::Vec4 color(xf, yf, 0.0f, 1.0f);
                    const int dx = x0 + xo;
                    const int dy = y0 + yo;

                    if (de::inBounds(dx, 0, refImg.getWidth()) && de::inBounds(dy, 0, refImg.getHeight()))
                        refImg.setPixel(dx, dy, tcu::RGBA(color));
                }
            }
        }

        // Compare
        {
            bool isOk = tcu::fuzzyCompare(log, "Result", "Image comparison result", refImg, testImg, threshold,
                                          tcu::COMPARE_LOG_RESULT);
            m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    isOk ? "Pass" : "Image comparison failed");
        }

        return STOP;
    }
};

class FrontFacingCase : public TestCase
{
public:
    FrontFacingCase(Context &context) : TestCase(context, "frontfacing", "gl_FrontFacing Test")
    {
    }

    IterateResult iterate(void)
    {
        // Test case renders two adjecent quads, where left is has front-facing
        // triagles and right back-facing. Color is selected based on gl_FrontFacing
        // value.

        TestLog &log             = m_testCtx.getLog();
        const glw::Functions &gl = m_context.getRenderContext().getFunctions();
        de::Random rnd(0x89f2c);
        const int width     = de::min(64, m_context.getRenderTarget().getWidth());
        const int height    = de::min(64, m_context.getRenderTarget().getHeight());
        const int viewportX = rnd.getInt(0, m_context.getRenderTarget().getWidth() - width);
        const int viewportY = rnd.getInt(0, m_context.getRenderTarget().getHeight() - height);
        const tcu::RGBA threshold =
            tcu::RGBA(1, 1, 1, 1) + m_context.getRenderTarget().getPixelFormat().getColorThreshold();

        tcu::Surface testImg(width, height);
        tcu::Surface refImg(width, height);

        const glu::ShaderProgram program(m_context.getRenderContext(),
                                         glu::makeVtxFragSources("#version 300 es\n"
                                                                 "in highp vec4 a_position;\n"
                                                                 "void main (void)\n"
                                                                 "{\n"
                                                                 "    gl_Position = a_position;\n"
                                                                 "}\n",

                                                                 "#version 300 es\n"
                                                                 "layout(location = 0) out mediump vec4 o_color;\n"
                                                                 "void main (void)\n"
                                                                 "{\n"
                                                                 "    if (gl_FrontFacing)\n"
                                                                 "        o_color = vec4(0.0, 1.0, 0.0, 1.0);\n"
                                                                 "    else\n"
                                                                 "        o_color = vec4(0.0, 0.0, 1.0, 1.0);\n"
                                                                 "}\n"));

        log << program;

        if (!program.isOk())
            throw tcu::TestError("Compile failed");

        // Draw with GL.
        {
            const float positions[]     = {-1.0f, 1.0f, 0.0f, 1.0f, -1.0f, -1.0f, 0.0f, 1.0f,
                                           1.0f,  1.0f, 0.0f, 1.0f, 1.0f,  -1.0f, 0.0f, 1.0f};
            const uint16_t indicesCCW[] = {0, 1, 2, 2, 1, 3};
            const uint16_t indicesCW[]  = {2, 1, 0, 3, 1, 2};

            glu::VertexArrayBinding posBinding = glu::va::Float("a_position", 4, 4, 0, &positions[0]);

            gl.useProgram(program.getProgram());

            gl.frontFace(GL_CCW);

            gl.viewport(viewportX, viewportY, width / 2, height / 2);
            glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding,
                      glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indicesCCW), &indicesCCW[0]));

            gl.viewport(viewportX + width / 2, viewportY, width - width / 2, height / 2);
            glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding,
                      glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indicesCW), &indicesCW[0]));

            gl.frontFace(GL_CW);

            gl.viewport(viewportX, viewportY + height / 2, width / 2, height - height / 2);
            glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding,
                      glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indicesCCW), &indicesCCW[0]));

            gl.viewport(viewportX + width / 2, viewportY + height / 2, width - width / 2, height - height / 2);
            glu::draw(m_context.getRenderContext(), program.getProgram(), 1, &posBinding,
                      glu::pr::Triangles(DE_LENGTH_OF_ARRAY(indicesCW), &indicesCW[0]));

            glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess());
            GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");
        }

        // Draw reference
        {
            for (int y = 0; y < refImg.getHeight() / 2; y++)
                for (int x = 0; x < refImg.getWidth() / 2; x++)
                    refImg.setPixel(x, y, tcu::RGBA::green());

            for (int y = 0; y < refImg.getHeight() / 2; y++)
                for (int x = refImg.getWidth() / 2; x < refImg.getWidth(); x++)
                    refImg.setPixel(x, y, tcu::RGBA::blue());

            for (int y = refImg.getHeight() / 2; y < refImg.getHeight(); y++)
                for (int x = 0; x < refImg.getWidth() / 2; x++)
                    refImg.setPixel(x, y, tcu::RGBA::blue());

            for (int y = refImg.getHeight() / 2; y < refImg.getHeight(); y++)
                for (int x = refImg.getWidth() / 2; x < refImg.getWidth(); x++)
                    refImg.setPixel(x, y, tcu::RGBA::green());
        }

        // Compare
        {
            bool isOk = tcu::pixelThresholdCompare(log, "Result", "Image comparison result", refImg, testImg, threshold,
                                                   tcu::COMPARE_LOG_RESULT);
            m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL,
                                    isOk ? "Pass" : "Image comparison failed");
        }

        return STOP;
    }
};

// VertexIDCase

class VertexIDCase : public TestCase
{
public:
    VertexIDCase(Context &context);
    ~VertexIDCase(void);

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

private:
    enum
    {
        MAX_VERTICES = 8 * 3 //!< 8 triangles, totals 24 vertices
    };

    void renderReference(const tcu::PixelBufferAccess &dst, const int numVertices, const uint16_t *const indices,
                         const tcu::Vec4 *const positions, const tcu::Vec4 *const colors, const int subpixelBits);

    glu::ShaderProgram *m_program;
    uint32_t m_positionBuffer;
    uint32_t m_elementBuffer;

    vector<tcu::Vec4> m_positions;
    vector<tcu::Vec4> m_colors;
    int m_viewportW;
    int m_viewportH;

    int m_iterNdx;
};

VertexIDCase::VertexIDCase(Context &context)
    : TestCase(context, "vertex_id", "gl_VertexID Test")
    , m_program(DE_NULL)
    , m_positionBuffer(0)
    , m_elementBuffer(0)
    , m_viewportW(0)
    , m_viewportH(0)
    , m_iterNdx(0)
{
}

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

void VertexIDCase::init(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    const int width          = m_context.getRenderTarget().getWidth();
    const int height         = m_context.getRenderTarget().getHeight();

    const int quadWidth  = 32;
    const int quadHeight = 32;

    if (width < quadWidth)
        throw tcu::NotSupportedError("Too small render target");

    const int maxQuadsX   = width / quadWidth;
    const int numVertices = MAX_VERTICES;

    const int numQuads  = numVertices / 6 + (numVertices % 6 != 0 ? 1 : 0);
    const int viewportW = de::min(numQuads, maxQuadsX) * quadWidth;
    const int viewportH = (numQuads / maxQuadsX + (numQuads % maxQuadsX != 0 ? 1 : 0)) * quadHeight;

    if (viewportH > height)
        throw tcu::NotSupportedError("Too small render target");

    DE_ASSERT(viewportW <= width && viewportH <= height);

    DE_ASSERT(!m_program);
    m_program = new glu::ShaderProgram(m_context.getRenderContext(),
                                       glu::makeVtxFragSources("#version 300 es\n"
                                                               "in highp vec4 a_position;\n"
                                                               "out mediump vec4 v_color;\n"
                                                               "uniform highp vec4 u_colors[24];\n"
                                                               "void main (void)\n"
                                                               "{\n"
                                                               "    gl_Position = a_position;\n"
                                                               "    v_color = u_colors[gl_VertexID];\n"
                                                               "}\n",

                                                               "#version 300 es\n"
                                                               "in mediump vec4 v_color;\n"
                                                               "layout(location = 0) out mediump vec4 o_color;\n"
                                                               "void main (void)\n"
                                                               "{\n"
                                                               "    o_color = v_color;\n"
                                                               "}\n"));

    m_testCtx.getLog() << *m_program;

    if (!m_program->isOk())
    {
        delete m_program;
        m_program = DE_NULL;
        throw tcu::TestError("Compile failed");
    }

    gl.genBuffers(1, &m_positionBuffer);
    gl.genBuffers(1, &m_elementBuffer);

    // Set colors (in dynamic memory to save static data space).
    m_colors.resize(numVertices);
    m_colors[0]  = tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
    m_colors[1]  = tcu::Vec4(0.5f, 1.0f, 0.5f, 1.0f);
    m_colors[2]  = tcu::Vec4(0.0f, 0.5f, 1.0f, 1.0f);
    m_colors[3]  = tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f);
    m_colors[4]  = tcu::Vec4(0.0f, 1.0f, 1.0f, 1.0f);
    m_colors[5]  = tcu::Vec4(0.5f, 0.0f, 0.0f, 1.0f);
    m_colors[6]  = tcu::Vec4(0.5f, 0.0f, 1.0f, 1.0f);
    m_colors[7]  = tcu::Vec4(0.5f, 0.0f, 0.5f, 1.0f);
    m_colors[8]  = tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f);
    m_colors[9]  = tcu::Vec4(0.5f, 1.0f, 0.0f, 1.0f);
    m_colors[10] = tcu::Vec4(0.0f, 0.5f, 0.0f, 1.0f);
    m_colors[11] = tcu::Vec4(0.5f, 1.0f, 1.0f, 1.0f);
    m_colors[12] = tcu::Vec4(0.0f, 0.0f, 1.0f, 1.0f);
    m_colors[13] = tcu::Vec4(1.0f, 0.0f, 0.5f, 1.0f);
    m_colors[14] = tcu::Vec4(0.0f, 0.5f, 0.5f, 1.0f);
    m_colors[15] = tcu::Vec4(1.0f, 1.0f, 0.5f, 1.0f);
    m_colors[16] = tcu::Vec4(1.0f, 0.0f, 1.0f, 1.0f);
    m_colors[17] = tcu::Vec4(1.0f, 0.5f, 0.0f, 1.0f);
    m_colors[18] = tcu::Vec4(0.0f, 1.0f, 0.5f, 1.0f);
    m_colors[19] = tcu::Vec4(1.0f, 0.5f, 1.0f, 1.0f);
    m_colors[20] = tcu::Vec4(1.0f, 1.0f, 0.0f, 1.0f);
    m_colors[21] = tcu::Vec4(1.0f, 0.5f, 0.5f, 1.0f);
    m_colors[22] = tcu::Vec4(0.0f, 0.0f, 0.5f, 1.0f);
    m_colors[23] = tcu::Vec4(1.0f, 1.0f, 1.0f, 1.0f);

    // Compute positions.
    m_positions.resize(numVertices);
    DE_ASSERT(numVertices % 3 == 0);
    for (int vtxNdx = 0; vtxNdx < numVertices; vtxNdx += 3)
    {
        const float h = 2.0f * float(quadHeight) / float(viewportH);
        const float w = 2.0f * float(quadWidth) / float(viewportW);

        const int triNdx  = vtxNdx / 3;
        const int quadNdx = triNdx / 2;
        const int quadY   = quadNdx / maxQuadsX;
        const int quadX   = quadNdx % maxQuadsX;

        const float x0 = -1.0f + float(quadX) * w;
        const float y0 = -1.0f + float(quadY) * h;

        if (triNdx % 2 == 0)
        {
            m_positions[vtxNdx + 0] = tcu::Vec4(x0, y0, 0.0f, 1.0f);
            m_positions[vtxNdx + 1] = tcu::Vec4(x0 + w, y0 + h, 0.0f, 1.0f);
            m_positions[vtxNdx + 2] = tcu::Vec4(x0, y0 + h, 0.0f, 1.0f);
        }
        else
        {
            m_positions[vtxNdx + 0] = tcu::Vec4(x0 + w, y0 + h, 0.0f, 1.0f);
            m_positions[vtxNdx + 1] = tcu::Vec4(x0, y0, 0.0f, 1.0f);
            m_positions[vtxNdx + 2] = tcu::Vec4(x0 + w, y0, 0.0f, 1.0f);
        }
    }

    m_viewportW = viewportW;
    m_viewportH = viewportH;
    m_iterNdx   = 0;

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

void VertexIDCase::deinit(void)
{
    delete m_program;
    m_program = DE_NULL;

    if (m_positionBuffer)
    {
        m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_positionBuffer);
        m_positionBuffer = 0;
    }

    if (m_elementBuffer)
    {
        m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_elementBuffer);
        m_elementBuffer = 0;
    }

    m_positions.clear();
    m_colors.clear();
}

class VertexIDReferenceShader : public rr::VertexShader, public rr::FragmentShader
{
public:
    enum
    {
        VARYINGLOC_COLOR = 0
    };

    VertexIDReferenceShader()
        : rr::VertexShader(2, 1)   // color and pos in => color out
        , rr::FragmentShader(1, 1) // color in => color out
    {
        this->rr::VertexShader::m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
        this->rr::VertexShader::m_inputs[1].type = rr::GENERICVECTYPE_FLOAT;

        this->rr::VertexShader::m_outputs[0].type      = rr::GENERICVECTYPE_FLOAT;
        this->rr::VertexShader::m_outputs[0].flatshade = false;

        this->rr::FragmentShader::m_inputs[0].type      = rr::GENERICVECTYPE_FLOAT;
        this->rr::FragmentShader::m_inputs[0].flatshade = false;

        this->rr::FragmentShader::m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
    }

    void shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets, const int numPackets) const
    {
        for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
        {
            const int positionAttrLoc = 0;
            const int colorAttrLoc    = 1;

            rr::VertexPacket &packet = *packets[packetNdx];

            // Transform to position
            packet.position = rr::readVertexAttribFloat(inputs[positionAttrLoc], packet.instanceNdx, packet.vertexNdx);

            // Pass color to FS
            packet.outputs[VARYINGLOC_COLOR] =
                rr::readVertexAttribFloat(inputs[colorAttrLoc], packet.instanceNdx, packet.vertexNdx);
        }
    }

    void shadeFragments(rr::FragmentPacket *packets, const int numPackets,
                        const rr::FragmentShadingContext &context) const
    {
        for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
        {
            rr::FragmentPacket &packet = packets[packetNdx];

            for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
                rr::writeFragmentOutput(context, packetNdx, fragNdx, 0,
                                        rr::readVarying<float>(packet, context, VARYINGLOC_COLOR, fragNdx));
        }
    }
};

void VertexIDCase::renderReference(const tcu::PixelBufferAccess &dst, const int numVertices,
                                   const uint16_t *const indices, const tcu::Vec4 *const positions,
                                   const tcu::Vec4 *const colors, const int subpixelBits)
{
    const rr::Renderer referenceRenderer;
    const rr::RenderState referenceState(
        (rr::ViewportState)(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(dst)), subpixelBits);
    const rr::RenderTarget referenceTarget(rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(dst));
    const VertexIDReferenceShader referenceShader;
    rr::VertexAttrib attribs[2];

    attribs[0].type            = rr::VERTEXATTRIBTYPE_FLOAT;
    attribs[0].size            = 4;
    attribs[0].stride          = 0;
    attribs[0].instanceDivisor = 0;
    attribs[0].pointer         = positions;

    attribs[1].type            = rr::VERTEXATTRIBTYPE_FLOAT;
    attribs[1].size            = 4;
    attribs[1].stride          = 0;
    attribs[1].instanceDivisor = 0;
    attribs[1].pointer         = colors;

    referenceRenderer.draw(
        rr::DrawCommand(referenceState, referenceTarget, rr::Program(&referenceShader, &referenceShader), 2, attribs,
                        rr::PrimitiveList(rr::PRIMITIVETYPE_TRIANGLES, numVertices, rr::DrawIndices(indices))));
}

VertexIDCase::IterateResult VertexIDCase::iterate(void)
{
    const glw::Functions &gl = m_context.getRenderContext().getFunctions();
    const int width          = m_context.getRenderTarget().getWidth();
    const int height         = m_context.getRenderTarget().getHeight();
    const int viewportW      = m_viewportW;
    const int viewportH      = m_viewportH;

    const float threshold = 0.02f;

    de::Random rnd(0xcf23ab1 ^ deInt32Hash(m_iterNdx));
    tcu::Surface refImg(viewportW, viewportH);
    tcu::Surface testImg(viewportW, viewportH);

    const int viewportX = rnd.getInt(0, width - viewportW);
    const int viewportY = rnd.getInt(0, height - viewportH);

    const int posLoc    = gl.getAttribLocation(m_program->getProgram(), "a_position");
    const int colorsLoc = gl.getUniformLocation(m_program->getProgram(), "u_colors[0]");
    const tcu::Vec4 clearColor(0.0f, 0.0f, 0.0f, 1.0f);

    // Setup common state.
    gl.viewport(viewportX, viewportY, viewportW, viewportH);
    gl.useProgram(m_program->getProgram());
    gl.bindBuffer(GL_ARRAY_BUFFER, m_positionBuffer);
    gl.enableVertexAttribArray(posLoc);
    gl.vertexAttribPointer(posLoc, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
    gl.uniform4fv(colorsLoc, (int)m_colors.size(), (const float *)&m_colors[0]);

    // Clear render target to black.
    gl.clearColor(clearColor.x(), clearColor.y(), clearColor.z(), clearColor.w());
    gl.clear(GL_COLOR_BUFFER_BIT);

    tcu::clear(refImg.getAccess(), clearColor);

    int subpixelBits = 0;
    gl.getIntegerv(GL_SUBPIXEL_BITS, &subpixelBits);

    if (m_iterNdx == 0)
    {
        tcu::ScopedLogSection logSection(m_testCtx.getLog(), "Iter0", "glDrawArrays()");
        vector<uint16_t> indices(m_positions.size());

        gl.bufferData(GL_ARRAY_BUFFER, (int)(m_positions.size() * sizeof(tcu::Vec4)), &m_positions[0], GL_DYNAMIC_DRAW);
        gl.drawArrays(GL_TRIANGLES, 0, (int)m_positions.size());

        glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess());
        GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");

        // Reference indices
        for (int ndx = 0; ndx < (int)indices.size(); ndx++)
            indices[ndx] = (uint16_t)ndx;

        renderReference(refImg.getAccess(), (int)m_positions.size(), &indices[0], &m_positions[0], &m_colors[0],
                        subpixelBits);
    }
    else if (m_iterNdx == 1)
    {
        tcu::ScopedLogSection logSection(m_testCtx.getLog(), "Iter1", "glDrawElements(), indices in client-side array");
        vector<uint16_t> indices(m_positions.size());
        vector<tcu::Vec4> mappedPos(m_positions.size());

        // Compute initial indices and suffle
        for (int ndx = 0; ndx < (int)indices.size(); ndx++)
            indices[ndx] = (uint16_t)ndx;
        rnd.shuffle(indices.begin(), indices.end());

        // Use indices to re-map positions.
        for (int ndx = 0; ndx < (int)indices.size(); ndx++)
            mappedPos[indices[ndx]] = m_positions[ndx];

        gl.bufferData(GL_ARRAY_BUFFER, (int)(m_positions.size() * sizeof(tcu::Vec4)), &mappedPos[0], GL_DYNAMIC_DRAW);
        gl.drawElements(GL_TRIANGLES, (int)indices.size(), GL_UNSIGNED_SHORT, &indices[0]);

        glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess());
        GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");

        renderReference(refImg.getAccess(), (int)indices.size(), &indices[0], &mappedPos[0], &m_colors[0],
                        subpixelBits);
    }
    else if (m_iterNdx == 2)
    {
        tcu::ScopedLogSection logSection(m_testCtx.getLog(), "Iter2", "glDrawElements(), indices in buffer");
        vector<uint16_t> indices(m_positions.size());
        vector<tcu::Vec4> mappedPos(m_positions.size());

        // Compute initial indices and suffle
        for (int ndx = 0; ndx < (int)indices.size(); ndx++)
            indices[ndx] = (uint16_t)ndx;
        rnd.shuffle(indices.begin(), indices.end());

        // Use indices to re-map positions.
        for (int ndx = 0; ndx < (int)indices.size(); ndx++)
            mappedPos[indices[ndx]] = m_positions[ndx];

        gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementBuffer);
        gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, (int)(indices.size() * sizeof(uint16_t)), &indices[0], GL_DYNAMIC_DRAW);

        gl.bufferData(GL_ARRAY_BUFFER, (int)(m_positions.size() * sizeof(tcu::Vec4)), &mappedPos[0], GL_DYNAMIC_DRAW);
        gl.drawElements(GL_TRIANGLES, (int)indices.size(), GL_UNSIGNED_SHORT, DE_NULL);

        glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, testImg.getAccess());
        GLU_EXPECT_NO_ERROR(gl.getError(), "Draw");

        tcu::clear(refImg.getAccess(), clearColor);
        renderReference(refImg.getAccess(), (int)indices.size(), &indices[0], &mappedPos[0], &m_colors[0],
                        subpixelBits);
    }
    else
        DE_ASSERT(false);

    if (!tcu::fuzzyCompare(m_testCtx.getLog(), "Result", "Image comparison result", refImg, testImg, threshold,
                           tcu::COMPARE_LOG_RESULT))
        m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");

    m_iterNdx += 1;
    return (m_iterNdx < 3) ? CONTINUE : STOP;
}

ShaderBuiltinVarTests::ShaderBuiltinVarTests(Context &context)
    : TestCaseGroup(context, "builtin_variable", "Built-in Variable Tests")
{
}

ShaderBuiltinVarTests::~ShaderBuiltinVarTests(void)
{
}

void ShaderBuiltinVarTests::init(void)
{
    // Builtin constants.

    static const struct
    {
        const char *caseName;
        const char *varName;
        ShaderBuiltinConstantCase::GetConstantValueFunc getValue;
    } builtinConstants[] = {
        // GLES 2.

        {"max_vertex_attribs", "gl_MaxVertexAttribs", getInteger<GL_MAX_VERTEX_ATTRIBS>},
        {"max_vertex_uniform_vectors", "gl_MaxVertexUniformVectors", getInteger<GL_MAX_VERTEX_UNIFORM_VECTORS>},
        {"max_fragment_uniform_vectors", "gl_MaxFragmentUniformVectors", getInteger<GL_MAX_FRAGMENT_UNIFORM_VECTORS>},
        {"max_texture_image_units", "gl_MaxTextureImageUnits", getInteger<GL_MAX_TEXTURE_IMAGE_UNITS>},
        {"max_vertex_texture_image_units", "gl_MaxVertexTextureImageUnits",
         getInteger<GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS>},
        {"max_combined_texture_image_units", "gl_MaxCombinedTextureImageUnits",
         getInteger<GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS>},
        {"max_draw_buffers", "gl_MaxDrawBuffers", getInteger<GL_MAX_DRAW_BUFFERS>},

        // GLES 3.

        {"max_vertex_output_vectors", "gl_MaxVertexOutputVectors",
         getVectorsFromComps<GL_MAX_VERTEX_OUTPUT_COMPONENTS>},
        {"max_fragment_input_vectors", "gl_MaxFragmentInputVectors",
         getVectorsFromComps<GL_MAX_FRAGMENT_INPUT_COMPONENTS>},
        {"min_program_texel_offset", "gl_MinProgramTexelOffset", getInteger<GL_MIN_PROGRAM_TEXEL_OFFSET>},
        {"max_program_texel_offset", "gl_MaxProgramTexelOffset", getInteger<GL_MAX_PROGRAM_TEXEL_OFFSET>}};

    for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(builtinConstants); ndx++)
    {
        const char *const caseName                                     = builtinConstants[ndx].caseName;
        const char *const varName                                      = builtinConstants[ndx].varName;
        const ShaderBuiltinConstantCase::GetConstantValueFunc getValue = builtinConstants[ndx].getValue;

        addChild(new ShaderBuiltinConstantCase(m_context, (string(caseName) + "_vertex").c_str(), varName, varName,
                                               getValue, glu::SHADERTYPE_VERTEX));
        addChild(new ShaderBuiltinConstantCase(m_context, (string(caseName) + "_fragment").c_str(), varName, varName,
                                               getValue, glu::SHADERTYPE_FRAGMENT));
    }

    addChild(new ShaderDepthRangeTest(m_context, "depth_range_vertex", "gl_DepthRange", true));
    addChild(new ShaderDepthRangeTest(m_context, "depth_range_fragment", "gl_DepthRange", false));

    // Vertex shader builtin variables.
    addChild(new VertexIDCase(m_context));
    // \todo [2013-03-20 pyry] gl_InstanceID -- tested in instancing tests quite thoroughly.

    // Fragment shader builtin variables.

    addChild(new FragCoordXYZCase(m_context));
    addChild(new FragCoordWCase(m_context));
    addChild(new PointCoordCase(m_context));
    addChild(new FrontFacingCase(m_context));
}

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