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

/*-------------------------------------------------------------------------
 * drawElements Quality Program OpenGL (ES) Module
 * -----------------------------------------------
 *
 * Copyright 2014 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 *
 *//*!
 * \file
 * \brief Vertex array and buffer tests
 *//*--------------------------------------------------------------------*/

#include "glsVertexArrayTests.hpp"

#include "deRandom.h"

#include "tcuTestLog.hpp"
#include "tcuPixelFormat.hpp"
#include "tcuRGBA.hpp"
#include "tcuSurface.hpp"
#include "tcuVector.hpp"
#include "tcuTestLog.hpp"
#include "tcuRenderTarget.hpp"
#include "tcuStringTemplate.hpp"
#include "tcuImageCompare.hpp"

#include "gluPixelTransfer.hpp"
#include "gluCallLogWrapper.hpp"

#include "sglrContext.hpp"
#include "sglrReferenceContext.hpp"
#include "sglrGLContext.hpp"

#include "deMath.h"
#include "deStringUtil.hpp"
#include "deArrayUtil.hpp"

#include <cstring>
#include <cmath>
#include <vector>
#include <sstream>
#include <limits>
#include <algorithm>

#include "glwDefs.hpp"
#include "glwEnums.hpp"

namespace deqp
{
namespace gls
{

using tcu::TestLog;
using namespace glw; // GL types

std::string Array::targetToString(Target target)
{
    static const char *targets[] = {
        "element_array", // TARGET_ELEMENT_ARRAY = 0,
        "array"          // TARGET_ARRAY,
    };

    return de::getSizedArrayElement<Array::TARGET_LAST>(targets, (int)target);
}

std::string Array::inputTypeToString(InputType type)
{
    static const char *types[] = {
        "float",  // INPUTTYPE_FLOAT = 0,
        "fixed",  // INPUTTYPE_FIXED,
        "double", // INPUTTYPE_DOUBLE

        "byte",  // INPUTTYPE_BYTE,
        "short", // INPUTTYPE_SHORT,

        "unsigned_byte",  // INPUTTYPE_UNSIGNED_BYTE,
        "unsigned_short", // INPUTTYPE_UNSIGNED_SHORT,

        "int",                   // INPUTTYPE_INT,
        "unsigned_int",          // INPUTTYPE_UNSIGNED_INT,
        "half",                  // INPUTTYPE_HALF,
        "usigned_int2_10_10_10", // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
        "int2_10_10_10"          // INPUTTYPE_INT_2_10_10_10,
    };

    return de::getSizedArrayElement<Array::INPUTTYPE_LAST>(types, (int)type);
}

std::string Array::outputTypeToString(OutputType type)
{
    static const char *types[] = {
        "float", // OUTPUTTYPE_FLOAT = 0,
        "vec2",  // OUTPUTTYPE_VEC2,
        "vec3",  // OUTPUTTYPE_VEC3,
        "vec4",  // OUTPUTTYPE_VEC4,

        "int",  // OUTPUTTYPE_INT,
        "uint", // OUTPUTTYPE_UINT,

        "ivec2", // OUTPUTTYPE_IVEC2,
        "ivec3", // OUTPUTTYPE_IVEC3,
        "ivec4", // OUTPUTTYPE_IVEC4,

        "uvec2", // OUTPUTTYPE_UVEC2,
        "uvec3", // OUTPUTTYPE_UVEC3,
        "uvec4", // OUTPUTTYPE_UVEC4,
    };

    return de::getSizedArrayElement<Array::OUTPUTTYPE_LAST>(types, (int)type);
}

std::string Array::usageTypeToString(Usage usage)
{
    static const char *usages[] = {
        "dynamic_draw", // USAGE_DYNAMIC_DRAW = 0,
        "static_draw",  // USAGE_STATIC_DRAW,
        "stream_draw",  // USAGE_STREAM_DRAW,

        "stream_read", // USAGE_STREAM_READ,
        "stream_copy", // USAGE_STREAM_COPY,

        "static_read", // USAGE_STATIC_READ,
        "static_copy", // USAGE_STATIC_COPY,

        "dynamic_read", // USAGE_DYNAMIC_READ,
        "dynamic_copy", // USAGE_DYNAMIC_COPY,
    };

    return de::getSizedArrayElement<Array::USAGE_LAST>(usages, (int)usage);
}

std::string Array::storageToString(Storage storage)
{
    static const char *storages[] = {
        "user_ptr", // STORAGE_USER = 0,
        "buffer"    // STORAGE_BUFFER,
    };

    return de::getSizedArrayElement<Array::STORAGE_LAST>(storages, (int)storage);
}

std::string Array::primitiveToString(Primitive primitive)
{
    static const char *primitives[] = {
        "points",        // PRIMITIVE_POINTS ,
        "triangles",     // PRIMITIVE_TRIANGLES,
        "triangle_fan",  // PRIMITIVE_TRIANGLE_FAN,
        "triangle_strip" // PRIMITIVE_TRIANGLE_STRIP,
    };

    return de::getSizedArrayElement<Array::PRIMITIVE_LAST>(primitives, (int)primitive);
}

int Array::inputTypeSize(InputType type)
{
    static const int size[] = {
        (int)sizeof(float),   // INPUTTYPE_FLOAT = 0,
        (int)sizeof(int32_t), // INPUTTYPE_FIXED,
        (int)sizeof(double),  // INPUTTYPE_DOUBLE

        (int)sizeof(int8_t),  // INPUTTYPE_BYTE,
        (int)sizeof(int16_t), // INPUTTYPE_SHORT,

        (int)sizeof(uint8_t),  // INPUTTYPE_UNSIGNED_BYTE,
        (int)sizeof(uint16_t), // INPUTTYPE_UNSIGNED_SHORT,

        (int)sizeof(int32_t),      // INPUTTYPE_INT,
        (int)sizeof(uint32_t),     // INPUTTYPE_UNSIGNED_INT,
        (int)sizeof(deFloat16),    // INPUTTYPE_HALF,
        (int)sizeof(uint32_t) / 4, // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
        (int)sizeof(uint32_t) / 4  // INPUTTYPE_INT_2_10_10_10,
    };

    return de::getSizedArrayElement<Array::INPUTTYPE_LAST>(size, (int)type);
}

static bool inputTypeIsFloatType(Array::InputType type)
{
    if (type == Array::INPUTTYPE_FLOAT)
        return true;
    if (type == Array::INPUTTYPE_FIXED)
        return true;
    if (type == Array::INPUTTYPE_DOUBLE)
        return true;
    if (type == Array::INPUTTYPE_HALF)
        return true;
    return false;
}

static bool outputTypeIsFloatType(Array::OutputType type)
{
    if (type == Array::OUTPUTTYPE_FLOAT || type == Array::OUTPUTTYPE_VEC2 || type == Array::OUTPUTTYPE_VEC3 ||
        type == Array::OUTPUTTYPE_VEC4)
        return true;

    return false;
}

template <class T>
inline T getRandom(deRandom &rnd, T min, T max);

template <>
inline GLValue::Float getRandom(deRandom &rnd, GLValue::Float min, GLValue::Float max)
{
    if (max < min)
        return min;

    return GLValue::Float::create(min + deRandom_getFloat(&rnd) * (max.to<float>() - min.to<float>()));
}

template <>
inline GLValue::Short getRandom(deRandom &rnd, GLValue::Short min, GLValue::Short max)
{
    if (max < min)
        return min;

    return GLValue::Short::create(
        (min == max ? min : (int16_t)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
}

template <>
inline GLValue::Ushort getRandom(deRandom &rnd, GLValue::Ushort min, GLValue::Ushort max)
{
    if (max < min)
        return min;

    return GLValue::Ushort::create(
        (min == max ? min : (uint16_t)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
}

template <>
inline GLValue::Byte getRandom(deRandom &rnd, GLValue::Byte min, GLValue::Byte max)
{
    if (max < min)
        return min;

    return GLValue::Byte::create(
        (min == max ? min : (int8_t)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
}

template <>
inline GLValue::Ubyte getRandom(deRandom &rnd, GLValue::Ubyte min, GLValue::Ubyte max)
{
    if (max < min)
        return min;

    return GLValue::Ubyte::create(
        (min == max ? min : (uint8_t)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
}

template <>
inline GLValue::Fixed getRandom(deRandom &rnd, GLValue::Fixed min, GLValue::Fixed max)
{
    if (max < min)
        return min;

    return GLValue::Fixed::create(
        (min == max ? min : min + (deRandom_getUint32(&rnd) % (max.to<uint32_t>() - min.to<uint32_t>()))));
}

template <>
inline GLValue::Half getRandom(deRandom &rnd, GLValue::Half min, GLValue::Half max)
{
    if (max < min)
        return min;

    float fMax      = max.to<float>();
    float fMin      = min.to<float>();
    GLValue::Half h = GLValue::Half::create(fMin + deRandom_getFloat(&rnd) * (fMax - fMin));
    return h;
}

template <>
inline GLValue::Int getRandom(deRandom &rnd, GLValue::Int min, GLValue::Int max)
{
    if (max < min)
        return min;

    return GLValue::Int::create(
        (min == max ? min : min + (deRandom_getUint32(&rnd) % (max.to<uint32_t>() - min.to<uint32_t>()))));
}

template <>
inline GLValue::Uint getRandom(deRandom &rnd, GLValue::Uint min, GLValue::Uint max)
{
    if (max < min)
        return min;

    return GLValue::Uint::create(
        (min == max ? min : min + (deRandom_getUint32(&rnd) % (max.to<uint32_t>() - min.to<uint32_t>()))));
}

template <>
inline GLValue::Double getRandom(deRandom &rnd, GLValue::Double min, GLValue::Double max)
{
    if (max < min)
        return min;

    return GLValue::Double::create(min + deRandom_getFloat(&rnd) * (max.to<float>() - min.to<float>()));
}

// Minimum difference required between coordinates
template <class T>
inline T minValue(void);

template <>
inline GLValue::Float minValue(void)
{
    return GLValue::Float::create(4 * 1.0f);
}

template <>
inline GLValue::Short minValue(void)
{
    return GLValue::Short::create(4 * 256);
}

template <>
inline GLValue::Ushort minValue(void)
{
    return GLValue::Ushort::create(4 * 256);
}

template <>
inline GLValue::Byte minValue(void)
{
    return GLValue::Byte::create(4 * 1);
}

template <>
inline GLValue::Ubyte minValue(void)
{
    return GLValue::Ubyte::create(4 * 2);
}

template <>
inline GLValue::Fixed minValue(void)
{
    return GLValue::Fixed::create(4 * 512);
}

template <>
inline GLValue::Int minValue(void)
{
    return GLValue::Int::create(4 * 16777216);
}

template <>
inline GLValue::Uint minValue(void)
{
    return GLValue::Uint::create(4 * 16777216);
}

template <>
inline GLValue::Half minValue(void)
{
    return GLValue::Half::create(4 * 1.0f);
}

template <>
inline GLValue::Double minValue(void)
{
    return GLValue::Double::create(4 * 1.0f);
}

template <class T>
static inline void alignmentSafeAssignment(char *dst, T val)
{
    std::memcpy(dst, &val, sizeof(T));
}

ContextArray::ContextArray(Storage storage, sglr::Context &context)
    : m_storage(storage)
    , m_ctx(context)
    , m_glBuffer(0)
    , m_bound(false)
    , m_attribNdx(0)
    , m_size(0)
    , m_data(DE_NULL)
    , m_componentCount(1)
    , m_target(Array::TARGET_ARRAY)
    , m_inputType(Array::INPUTTYPE_FLOAT)
    , m_outputType(Array::OUTPUTTYPE_VEC4)
    , m_normalize(false)
    , m_stride(0)
    , m_offset(0)
{
    if (m_storage == STORAGE_BUFFER)
    {
        m_ctx.genBuffers(1, &m_glBuffer);
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glGenBuffers()");
    }
}

ContextArray::~ContextArray(void)
{
    if (m_storage == STORAGE_BUFFER)
    {
        m_ctx.deleteBuffers(1, &m_glBuffer);
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDeleteBuffers()");
    }
    else if (m_storage == STORAGE_USER)
        delete[] m_data;
    else
        DE_ASSERT(false);
}

Array *ContextArrayPack::getArray(int i)
{
    return m_arrays.at(i);
}

void ContextArray::data(Target target, int size, const char *ptr, Usage usage)
{
    m_size   = size;
    m_target = target;

    if (m_storage == STORAGE_BUFFER)
    {
        m_ctx.bindBuffer(targetToGL(target), m_glBuffer);
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");

        m_ctx.bufferData(targetToGL(target), size, ptr, usageToGL(usage));
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBufferData()");
    }
    else if (m_storage == STORAGE_USER)
    {
        if (m_data)
            delete[] m_data;

        m_data = new char[size];
        std::memcpy(m_data, ptr, size);
    }
    else
        DE_ASSERT(false);
}

void ContextArray::subdata(Target target, int offset, int size, const char *ptr)
{
    m_target = target;

    if (m_storage == STORAGE_BUFFER)
    {
        m_ctx.bindBuffer(targetToGL(target), m_glBuffer);
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");

        m_ctx.bufferSubData(targetToGL(target), offset, size, ptr);
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBufferSubData()");
    }
    else if (m_storage == STORAGE_USER)
        std::memcpy(m_data + offset, ptr, size);
    else
        DE_ASSERT(false);
}

void ContextArray::bind(int attribNdx, int offset, int size, InputType inputType, OutputType outType, bool normalized,
                        int stride)
{
    m_attribNdx      = attribNdx;
    m_bound          = true;
    m_componentCount = size;
    m_inputType      = inputType;
    m_outputType     = outType;
    m_normalize      = normalized;
    m_stride         = stride;
    m_offset         = offset;
}

void ContextArray::bindIndexArray(Array::Target target)
{
    if (m_storage == STORAGE_USER)
    {
    }
    else if (m_storage == STORAGE_BUFFER)
    {
        m_ctx.bindBuffer(targetToGL(target), m_glBuffer);
    }
}

void ContextArray::glBind(uint32_t loc)
{
    if (m_storage == STORAGE_BUFFER)
    {
        m_ctx.bindBuffer(targetToGL(m_target), m_glBuffer);
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");

        if (!inputTypeIsFloatType(m_inputType))
        {
            // Input is not float type

            if (outputTypeIsFloatType(m_outputType))
            {
                // Output type is float type
                m_ctx.vertexAttribPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_normalize, m_stride,
                                          (GLvoid *)((GLintptr)m_offset));
                GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribPointer()");
            }
            else
            {
                // Output type is int type
                m_ctx.vertexAttribIPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_stride,
                                           (GLvoid *)((GLintptr)m_offset));
                GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribIPointer()");
            }
        }
        else
        {
            // Input type is float type

            // Output type must be float type
            DE_ASSERT(m_outputType == OUTPUTTYPE_FLOAT || m_outputType == OUTPUTTYPE_VEC2 ||
                      m_outputType == OUTPUTTYPE_VEC3 || m_outputType == OUTPUTTYPE_VEC4);

            m_ctx.vertexAttribPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_normalize, m_stride,
                                      (GLvoid *)((GLintptr)m_offset));
            GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribPointer()");
        }

        m_ctx.bindBuffer(targetToGL(m_target), 0);
    }
    else if (m_storage == STORAGE_USER)
    {
        m_ctx.bindBuffer(targetToGL(m_target), 0);
        GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");

        if (!inputTypeIsFloatType(m_inputType))
        {
            // Input is not float type

            if (outputTypeIsFloatType(m_outputType))
            {
                // Output type is float type
                m_ctx.vertexAttribPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_normalize, m_stride,
                                          m_data + m_offset);
                GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribPointer()");
            }
            else
            {
                // Output type is int type
                m_ctx.vertexAttribIPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_stride,
                                           m_data + m_offset);
                GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribIPointer()");
            }
        }
        else
        {
            // Input type is float type

            // Output type must be float type
            DE_ASSERT(m_outputType == OUTPUTTYPE_FLOAT || m_outputType == OUTPUTTYPE_VEC2 ||
                      m_outputType == OUTPUTTYPE_VEC3 || m_outputType == OUTPUTTYPE_VEC4);

            m_ctx.vertexAttribPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_normalize, m_stride,
                                      m_data + m_offset);
            GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribPointer()");
        }
    }
    else
        DE_ASSERT(false);
}

GLenum ContextArray::targetToGL(Array::Target target)
{
    static const GLenum targets[] = {
        GL_ELEMENT_ARRAY_BUFFER, // TARGET_ELEMENT_ARRAY = 0,
        GL_ARRAY_BUFFER          // TARGET_ARRAY,
    };

    return de::getSizedArrayElement<Array::TARGET_LAST>(targets, (int)target);
}

GLenum ContextArray::usageToGL(Array::Usage usage)
{
    static const GLenum usages[] = {
        GL_DYNAMIC_DRAW, // USAGE_DYNAMIC_DRAW = 0,
        GL_STATIC_DRAW,  // USAGE_STATIC_DRAW,
        GL_STREAM_DRAW,  // USAGE_STREAM_DRAW,

        GL_STREAM_READ, // USAGE_STREAM_READ,
        GL_STREAM_COPY, // USAGE_STREAM_COPY,

        GL_STATIC_READ, // USAGE_STATIC_READ,
        GL_STATIC_COPY, // USAGE_STATIC_COPY,

        GL_DYNAMIC_READ, // USAGE_DYNAMIC_READ,
        GL_DYNAMIC_COPY  // USAGE_DYNAMIC_COPY,
    };

    return de::getSizedArrayElement<Array::USAGE_LAST>(usages, (int)usage);
}

GLenum ContextArray::inputTypeToGL(Array::InputType type)
{
    static const GLenum types[] = {
        GL_FLOAT,          // INPUTTYPE_FLOAT = 0,
        GL_FIXED,          // INPUTTYPE_FIXED,
        GL_DOUBLE,         // INPUTTYPE_DOUBLE
        GL_BYTE,           // INPUTTYPE_BYTE,
        GL_SHORT,          // INPUTTYPE_SHORT,
        GL_UNSIGNED_BYTE,  // INPUTTYPE_UNSIGNED_BYTE,
        GL_UNSIGNED_SHORT, // INPUTTYPE_UNSIGNED_SHORT,

        GL_INT,                         // INPUTTYPE_INT,
        GL_UNSIGNED_INT,                // INPUTTYPE_UNSIGNED_INT,
        GL_HALF_FLOAT,                  // INPUTTYPE_HALF,
        GL_UNSIGNED_INT_2_10_10_10_REV, // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
        GL_INT_2_10_10_10_REV           // INPUTTYPE_INT_2_10_10_10,
    };

    return de::getSizedArrayElement<Array::INPUTTYPE_LAST>(types, (int)type);
}

std::string ContextArray::outputTypeToGLType(Array::OutputType type)
{
    static const char *types[] = {
        "float", // OUTPUTTYPE_FLOAT = 0,
        "vec2",  // OUTPUTTYPE_VEC2,
        "vec3",  // OUTPUTTYPE_VEC3,
        "vec4",  // OUTPUTTYPE_VEC4,

        "int",  // OUTPUTTYPE_INT,
        "uint", // OUTPUTTYPE_UINT,

        "ivec2", // OUTPUTTYPE_IVEC2,
        "ivec3", // OUTPUTTYPE_IVEC3,
        "ivec4", // OUTPUTTYPE_IVEC4,

        "uvec2", // OUTPUTTYPE_UVEC2,
        "uvec3", // OUTPUTTYPE_UVEC3,
        "uvec4", // OUTPUTTYPE_UVEC4,
    };

    return de::getSizedArrayElement<Array::OUTPUTTYPE_LAST>(types, (int)type);
}

GLenum ContextArray::primitiveToGL(Array::Primitive primitive)
{
    static const GLenum primitives[] = {
        GL_POINTS,        // PRIMITIVE_POINTS = 0,
        GL_TRIANGLES,     // PRIMITIVE_TRIANGLES,
        GL_TRIANGLE_FAN,  // PRIMITIVE_TRIANGLE_FAN,
        GL_TRIANGLE_STRIP // PRIMITIVE_TRIANGLE_STRIP,
    };

    return de::getSizedArrayElement<Array::PRIMITIVE_LAST>(primitives, (int)primitive);
}

ContextArrayPack::ContextArrayPack(glu::RenderContext &renderCtx, sglr::Context &drawContext)
    : m_renderCtx(renderCtx)
    , m_ctx(drawContext)
    , m_program(DE_NULL)
    , m_screen(std::min(512, renderCtx.getRenderTarget().getWidth()),
               std::min(512, renderCtx.getRenderTarget().getHeight()))
{
}

ContextArrayPack::~ContextArrayPack(void)
{
    for (std::vector<ContextArray *>::iterator itr = m_arrays.begin(); itr != m_arrays.end(); itr++)
        delete *itr;

    delete m_program;
}

int ContextArrayPack::getArrayCount(void)
{
    return (int)m_arrays.size();
}

void ContextArrayPack::newArray(Array::Storage storage)
{
    m_arrays.push_back(new ContextArray(storage, m_ctx));
}

class ContextShaderProgram : public sglr::ShaderProgram
{
public:
    ContextShaderProgram(const glu::RenderContext &ctx, const std::vector<ContextArray *> &arrays);

    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;

private:
    static std::string genVertexSource(const glu::RenderContext &ctx, const std::vector<ContextArray *> &arrays);
    static std::string genFragmentSource(const glu::RenderContext &ctx);
    static rr::GenericVecType mapOutputType(const Array::OutputType &type);
    static int getComponentCount(const Array::OutputType &type);

    static sglr::pdec::ShaderProgramDeclaration createProgramDeclaration(const glu::RenderContext &ctx,
                                                                         const std::vector<ContextArray *> &arrays);

    std::vector<int> m_componentCount;
    std::vector<rr::GenericVecType> m_attrType;
};

ContextShaderProgram::ContextShaderProgram(const glu::RenderContext &ctx, const std::vector<ContextArray *> &arrays)
    : sglr::ShaderProgram(createProgramDeclaration(ctx, arrays))
    , m_componentCount(arrays.size())
    , m_attrType(arrays.size())
{
    for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
    {
        m_componentCount[arrayNdx] = getComponentCount(arrays[arrayNdx]->getOutputType());
        m_attrType[arrayNdx]       = mapOutputType(arrays[arrayNdx]->getOutputType());
    }
}

template <typename T>
void calcShaderColorCoord(tcu::Vec2 &coord, tcu::Vec3 &color, const tcu::Vector<T, 4> &attribValue, bool isCoordinate,
                          int numComponents)
{
    if (isCoordinate)
        switch (numComponents)
        {
        case 1:
            coord = tcu::Vec2((float)attribValue.x(), (float)attribValue.x());
            break;
        case 2:
            coord = tcu::Vec2((float)attribValue.x(), (float)attribValue.y());
            break;
        case 3:
            coord = tcu::Vec2((float)attribValue.x() + (float)attribValue.z(), (float)attribValue.y());
            break;
        case 4:
            coord = tcu::Vec2((float)attribValue.x() + (float)attribValue.z(),
                              (float)attribValue.y() + (float)attribValue.w());
            break;

        default:
            DE_ASSERT(false);
        }
    else
    {
        switch (numComponents)
        {
        case 1:
            color = color * (float)attribValue.x();
            break;

        case 2:
            color.x() = color.x() * (float)attribValue.x();
            color.y() = color.y() * (float)attribValue.y();
            break;

        case 3:
            color.x() = color.x() * (float)attribValue.x();
            color.y() = color.y() * (float)attribValue.y();
            color.z() = color.z() * (float)attribValue.z();
            break;

        case 4:
            color.x() = color.x() * (float)attribValue.x() * (float)attribValue.w();
            color.y() = color.y() * (float)attribValue.y() * (float)attribValue.w();
            color.z() = color.z() * (float)attribValue.z() * (float)attribValue.w();
            break;

        default:
            DE_ASSERT(false);
        }
    }
}

void ContextShaderProgram::shadeVertices(const rr::VertexAttrib *inputs, rr::VertexPacket *const *packets,
                                         const int numPackets) const
{
    const float u_coordScale = getUniformByName("u_coordScale").value.f;
    const float u_colorScale = getUniformByName("u_colorScale").value.f;

    for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
    {
        const size_t varyingLocColor = 0;

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

        // Calc output color
        tcu::Vec2 coord = tcu::Vec2(1.0, 1.0);
        tcu::Vec3 color = tcu::Vec3(1.0, 1.0, 1.0);

        for (int attribNdx = 0; attribNdx < (int)m_attrType.size(); attribNdx++)
        {
            const int numComponents = m_componentCount[attribNdx];

            switch (m_attrType[attribNdx])
            {
            case rr::GENERICVECTYPE_FLOAT:
                calcShaderColorCoord(coord, color,
                                     rr::readVertexAttribFloat(inputs[attribNdx], packet.instanceNdx, packet.vertexNdx),
                                     attribNdx == 0, numComponents);
                break;
            case rr::GENERICVECTYPE_INT32:
                calcShaderColorCoord(coord, color,
                                     rr::readVertexAttribInt(inputs[attribNdx], packet.instanceNdx, packet.vertexNdx),
                                     attribNdx == 0, numComponents);
                break;
            case rr::GENERICVECTYPE_UINT32:
                calcShaderColorCoord(coord, color,
                                     rr::readVertexAttribUint(inputs[attribNdx], packet.instanceNdx, packet.vertexNdx),
                                     attribNdx == 0, numComponents);
                break;
            default:
                DE_ASSERT(false);
            }
        }

        // Transform position
        {
            packet.position = tcu::Vec4(u_coordScale * coord.x(), u_coordScale * coord.y(), 1.0f, 1.0f);
        }

        // Pass color to FS
        {
            packet.outputs[varyingLocColor] =
                tcu::Vec4(u_colorScale * color.x(), u_colorScale * color.y(), u_colorScale * color.z(), 1.0f);
        }
    }
}

void ContextShaderProgram::shadeFragments(rr::FragmentPacket *packets, const int numPackets,
                                          const rr::FragmentShadingContext &context) const
{
    const size_t varyingLocColor = 0;

    // Triangles are flashaded
    tcu::Vec4 color = rr::readTriangleVarying<float>(packets[0], context, varyingLocColor, 0);

    for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
        for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
            rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
}

std::string ContextShaderProgram::genVertexSource(const glu::RenderContext &ctx,
                                                  const std::vector<ContextArray *> &arrays)
{
    std::stringstream vertexShaderTmpl;
    std::map<std::string, std::string> params;

    if (glu::isGLSLVersionSupported(ctx.getType(), glu::GLSL_VERSION_300_ES))
    {
        params["VTX_IN"]     = "in";
        params["VTX_OUT"]    = "out";
        params["FRAG_IN"]    = "in";
        params["FRAG_COLOR"] = "dEQP_FragColor";
        params["VTX_HDR"]    = "#version 300 es\n";
        params["FRAG_HDR"]   = "#version 300 es\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n";
    }
    else if (glu::isGLSLVersionSupported(ctx.getType(), glu::GLSL_VERSION_100_ES))
    {
        params["VTX_IN"]     = "attribute";
        params["VTX_OUT"]    = "varying";
        params["FRAG_IN"]    = "varying";
        params["FRAG_COLOR"] = "gl_FragColor";
        params["VTX_HDR"]    = "";
        params["FRAG_HDR"]   = "";
    }
    else if (glu::isGLSLVersionSupported(ctx.getType(), glu::GLSL_VERSION_330))
    {
        params["VTX_IN"]     = "in";
        params["VTX_OUT"]    = "out";
        params["FRAG_IN"]    = "in";
        params["FRAG_COLOR"] = "dEQP_FragColor";
        params["VTX_HDR"]    = "#version 330\n";
        params["FRAG_HDR"]   = "#version 330\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n";
    }
    else
        DE_ASSERT(false);

    vertexShaderTmpl << "${VTX_HDR}";

    for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
    {
        vertexShaderTmpl << "${VTX_IN} highp " << ContextArray::outputTypeToGLType(arrays[arrayNdx]->getOutputType())
                         << " a_" << arrays[arrayNdx]->getAttribNdx() << ";\n";
    }

    vertexShaderTmpl << "uniform highp float u_coordScale;\n"
                        "uniform highp float u_colorScale;\n"
                        "${VTX_OUT} mediump vec4 v_color;\n"
                        "void main(void)\n"
                        "{\n"
                        "\tgl_PointSize = 1.0;\n"
                        "\thighp vec2 coord = vec2(1.0, 1.0);\n"
                        "\thighp vec3 color = vec3(1.0, 1.0, 1.0);\n";

    for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
    {
        if (arrays[arrayNdx]->getAttribNdx() == 0)
        {
            switch (arrays[arrayNdx]->getOutputType())
            {
            case (Array::OUTPUTTYPE_FLOAT):
                vertexShaderTmpl << "\tcoord = vec2(a_0);\n";
                break;

            case (Array::OUTPUTTYPE_VEC2):
                vertexShaderTmpl << "\tcoord = a_0.xy;\n";
                break;

            case (Array::OUTPUTTYPE_VEC3):
                vertexShaderTmpl << "\tcoord = a_0.xy;\n"
                                    "\tcoord.x = coord.x + a_0.z;\n";
                break;

            case (Array::OUTPUTTYPE_VEC4):
                vertexShaderTmpl << "\tcoord = a_0.xy;\n"
                                    "\tcoord += a_0.zw;\n";
                break;

            case (Array::OUTPUTTYPE_IVEC2):
            case (Array::OUTPUTTYPE_UVEC2):
                vertexShaderTmpl << "\tcoord = vec2(a_0.xy);\n";
                break;

            case (Array::OUTPUTTYPE_IVEC3):
            case (Array::OUTPUTTYPE_UVEC3):
                vertexShaderTmpl << "\tcoord = vec2(a_0.xy);\n"
                                    "\tcoord.x = coord.x + float(a_0.z);\n";
                break;

            case (Array::OUTPUTTYPE_IVEC4):
            case (Array::OUTPUTTYPE_UVEC4):
                vertexShaderTmpl << "\tcoord = vec2(a_0.xy);\n"
                                    "\tcoord += vec2(a_0.zw);\n";
                break;

            default:
                DE_ASSERT(false);
                break;
            }
            continue;
        }

        switch (arrays[arrayNdx]->getOutputType())
        {
        case (Array::OUTPUTTYPE_FLOAT):
            vertexShaderTmpl << "\tcolor = color * a_" << arrays[arrayNdx]->getAttribNdx() << ";\n";
            break;

        case (Array::OUTPUTTYPE_VEC2):
            vertexShaderTmpl << "\tcolor.rg = color.rg * a_" << arrays[arrayNdx]->getAttribNdx() << ".xy;\n";
            break;

        case (Array::OUTPUTTYPE_VEC3):
            vertexShaderTmpl << "\tcolor = color.rgb * a_" << arrays[arrayNdx]->getAttribNdx() << ".xyz;\n";
            break;

        case (Array::OUTPUTTYPE_VEC4):
            vertexShaderTmpl << "\tcolor = color.rgb * a_" << arrays[arrayNdx]->getAttribNdx() << ".xyz * a_"
                             << arrays[arrayNdx]->getAttribNdx() << ".w;\n";
            break;

        default:
            DE_ASSERT(false);
            break;
        }
    }

    vertexShaderTmpl << "\tv_color = vec4(u_colorScale * color, 1.0);\n"
                        "\tgl_Position = vec4(u_coordScale * coord, 1.0, 1.0);\n"
                        "}\n";

    return tcu::StringTemplate(vertexShaderTmpl.str().c_str()).specialize(params);
}

std::string ContextShaderProgram::genFragmentSource(const glu::RenderContext &ctx)
{
    std::map<std::string, std::string> params;

    if (glu::isGLSLVersionSupported(ctx.getType(), glu::GLSL_VERSION_300_ES))
    {
        params["VTX_IN"]     = "in";
        params["VTX_OUT"]    = "out";
        params["FRAG_IN"]    = "in";
        params["FRAG_COLOR"] = "dEQP_FragColor";
        params["VTX_HDR"]    = "#version 300 es\n";
        params["FRAG_HDR"]   = "#version 300 es\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n";
    }
    else if (glu::isGLSLVersionSupported(ctx.getType(), glu::GLSL_VERSION_100_ES))
    {
        params["VTX_IN"]     = "attribute";
        params["VTX_OUT"]    = "varying";
        params["FRAG_IN"]    = "varying";
        params["FRAG_COLOR"] = "gl_FragColor";
        params["VTX_HDR"]    = "";
        params["FRAG_HDR"]   = "";
    }
    else if (glu::isGLSLVersionSupported(ctx.getType(), glu::GLSL_VERSION_330))
    {
        params["VTX_IN"]     = "in";
        params["VTX_OUT"]    = "out";
        params["FRAG_IN"]    = "in";
        params["FRAG_COLOR"] = "dEQP_FragColor";
        params["VTX_HDR"]    = "#version 330\n";
        params["FRAG_HDR"]   = "#version 330\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n";
    }
    else
        DE_ASSERT(false);

    static const char *fragmentShaderTmpl = "${FRAG_HDR}"
                                            "${FRAG_IN} mediump vec4 v_color;\n"
                                            "void main(void)\n"
                                            "{\n"
                                            "\t${FRAG_COLOR} = v_color;\n"
                                            "}\n";

    return tcu::StringTemplate(fragmentShaderTmpl).specialize(params);
}

rr::GenericVecType ContextShaderProgram::mapOutputType(const Array::OutputType &type)
{
    switch (type)
    {
    case (Array::OUTPUTTYPE_FLOAT):
    case (Array::OUTPUTTYPE_VEC2):
    case (Array::OUTPUTTYPE_VEC3):
    case (Array::OUTPUTTYPE_VEC4):
        return rr::GENERICVECTYPE_FLOAT;

    case (Array::OUTPUTTYPE_INT):
    case (Array::OUTPUTTYPE_IVEC2):
    case (Array::OUTPUTTYPE_IVEC3):
    case (Array::OUTPUTTYPE_IVEC4):
        return rr::GENERICVECTYPE_INT32;

    case (Array::OUTPUTTYPE_UINT):
    case (Array::OUTPUTTYPE_UVEC2):
    case (Array::OUTPUTTYPE_UVEC3):
    case (Array::OUTPUTTYPE_UVEC4):
        return rr::GENERICVECTYPE_UINT32;

    default:
        DE_ASSERT(false);
        return rr::GENERICVECTYPE_LAST;
    }
}

int ContextShaderProgram::getComponentCount(const Array::OutputType &type)
{
    switch (type)
    {
    case (Array::OUTPUTTYPE_FLOAT):
    case (Array::OUTPUTTYPE_INT):
    case (Array::OUTPUTTYPE_UINT):
        return 1;

    case (Array::OUTPUTTYPE_VEC2):
    case (Array::OUTPUTTYPE_IVEC2):
    case (Array::OUTPUTTYPE_UVEC2):
        return 2;

    case (Array::OUTPUTTYPE_VEC3):
    case (Array::OUTPUTTYPE_IVEC3):
    case (Array::OUTPUTTYPE_UVEC3):
        return 3;

    case (Array::OUTPUTTYPE_VEC4):
    case (Array::OUTPUTTYPE_IVEC4):
    case (Array::OUTPUTTYPE_UVEC4):
        return 4;

    default:
        DE_ASSERT(false);
        return 0;
    }
}

sglr::pdec::ShaderProgramDeclaration ContextShaderProgram::createProgramDeclaration(
    const glu::RenderContext &ctx, const std::vector<ContextArray *> &arrays)
{
    sglr::pdec::ShaderProgramDeclaration decl;

    for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
        decl << sglr::pdec::VertexAttribute(std::string("a_") + de::toString(arrayNdx),
                                            mapOutputType(arrays[arrayNdx]->getOutputType()));

    decl << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT);
    decl << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT);

    decl << sglr::pdec::VertexSource(genVertexSource(ctx, arrays));
    decl << sglr::pdec::FragmentSource(genFragmentSource(ctx));

    decl << sglr::pdec::Uniform("u_coordScale", glu::TYPE_FLOAT);
    decl << sglr::pdec::Uniform("u_colorScale", glu::TYPE_FLOAT);

    return decl;
}

void ContextArrayPack::updateProgram(void)
{
    delete m_program;
    m_program = new ContextShaderProgram(m_renderCtx, m_arrays);
}

void ContextArrayPack::render(Array::Primitive primitive, int firstVertex, int vertexCount, bool useVao,
                              float coordScale, float colorScale)
{
    uint32_t program = 0;
    uint32_t vaoId   = 0;

    updateProgram();

    m_ctx.viewport(0, 0, m_screen.getWidth(), m_screen.getHeight());
    m_ctx.clearColor(0.0, 0.0, 0.0, 1.0);
    m_ctx.clear(GL_COLOR_BUFFER_BIT);

    program = m_ctx.createProgram(m_program);

    m_ctx.useProgram(program);
    GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glUseProgram()");

    m_ctx.uniform1f(m_ctx.getUniformLocation(program, "u_coordScale"), coordScale);
    m_ctx.uniform1f(m_ctx.getUniformLocation(program, "u_colorScale"), colorScale);

    if (useVao)
    {
        m_ctx.genVertexArrays(1, &vaoId);
        m_ctx.bindVertexArray(vaoId);
    }

    for (int arrayNdx = 0; arrayNdx < (int)m_arrays.size(); arrayNdx++)
    {
        if (m_arrays[arrayNdx]->isBound())
        {
            std::stringstream attribName;
            attribName << "a_" << m_arrays[arrayNdx]->getAttribNdx();

            uint32_t loc = m_ctx.getAttribLocation(program, attribName.str().c_str());
            m_ctx.enableVertexAttribArray(loc);
            GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glEnableVertexAttribArray()");

            m_arrays[arrayNdx]->glBind(loc);
        }
    }

    DE_ASSERT((firstVertex % 6) == 0);
    m_ctx.drawArrays(ContextArray::primitiveToGL(primitive), firstVertex, vertexCount - firstVertex);
    GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawArrays()");

    for (int arrayNdx = 0; arrayNdx < (int)m_arrays.size(); arrayNdx++)
    {
        if (m_arrays[arrayNdx]->isBound())
        {
            std::stringstream attribName;
            attribName << "a_" << m_arrays[arrayNdx]->getAttribNdx();

            uint32_t loc = m_ctx.getAttribLocation(program, attribName.str().c_str());

            m_ctx.disableVertexAttribArray(loc);
            GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDisableVertexAttribArray()");
        }
    }

    if (useVao)
        m_ctx.deleteVertexArrays(1, &vaoId);

    m_ctx.deleteProgram(program);
    m_ctx.useProgram(0);
    m_ctx.readPixels(m_screen, 0, 0, m_screen.getWidth(), m_screen.getHeight());
}

// GLValue

GLValue GLValue::getMaxValue(Array::InputType type)
{
    GLValue rangesHi[(int)Array::INPUTTYPE_LAST];

    rangesHi[(int)Array::INPUTTYPE_FLOAT]          = GLValue(Float::create(127.0f));
    rangesHi[(int)Array::INPUTTYPE_DOUBLE]         = GLValue(Double::create(127.0f));
    rangesHi[(int)Array::INPUTTYPE_BYTE]           = GLValue(Byte::create(127));
    rangesHi[(int)Array::INPUTTYPE_UNSIGNED_BYTE]  = GLValue(Ubyte::create(255));
    rangesHi[(int)Array::INPUTTYPE_UNSIGNED_SHORT] = GLValue(Ushort::create(65530));
    rangesHi[(int)Array::INPUTTYPE_SHORT]          = GLValue(Short::create(32760));
    rangesHi[(int)Array::INPUTTYPE_FIXED]          = GLValue(Fixed::create(32760));
    rangesHi[(int)Array::INPUTTYPE_INT]            = GLValue(Int::create(2147483647));
    rangesHi[(int)Array::INPUTTYPE_UNSIGNED_INT]   = GLValue(Uint::create(4294967295u));
    rangesHi[(int)Array::INPUTTYPE_HALF]           = GLValue(Half::create(256.0f));

    return rangesHi[(int)type];
}

GLValue GLValue::getMinValue(Array::InputType type)
{
    GLValue rangesLo[(int)Array::INPUTTYPE_LAST];

    rangesLo[(int)Array::INPUTTYPE_FLOAT]          = GLValue(Float::create(-127.0f));
    rangesLo[(int)Array::INPUTTYPE_DOUBLE]         = GLValue(Double::create(-127.0f));
    rangesLo[(int)Array::INPUTTYPE_BYTE]           = GLValue(Byte::create(-127));
    rangesLo[(int)Array::INPUTTYPE_UNSIGNED_BYTE]  = GLValue(Ubyte::create(0));
    rangesLo[(int)Array::INPUTTYPE_UNSIGNED_SHORT] = GLValue(Ushort::create(0));
    rangesLo[(int)Array::INPUTTYPE_SHORT]          = GLValue(Short::create(-32760));
    rangesLo[(int)Array::INPUTTYPE_FIXED]          = GLValue(Fixed::create(-32760));
    rangesLo[(int)Array::INPUTTYPE_INT]            = GLValue(Int::create(-2147483647));
    rangesLo[(int)Array::INPUTTYPE_UNSIGNED_INT]   = GLValue(Uint::create(0));
    rangesLo[(int)Array::INPUTTYPE_HALF]           = GLValue(Half::create(-256.0f));

    return rangesLo[(int)type];
}

float GLValue::toFloat(void) const
{
    switch (type)
    {
    case Array::INPUTTYPE_FLOAT:
        return fl.getValue();

    case Array::INPUTTYPE_BYTE:
        return b.getValue();

    case Array::INPUTTYPE_UNSIGNED_BYTE:
        return ub.getValue();

    case Array::INPUTTYPE_SHORT:
        return s.getValue();

    case Array::INPUTTYPE_UNSIGNED_SHORT:
        return us.getValue();

    case Array::INPUTTYPE_FIXED:
    {
        int maxValue = 65536;
        return (float)(double(2 * fi.getValue() + 1) / (maxValue - 1));
    }

    case Array::INPUTTYPE_UNSIGNED_INT:
        return (float)ui.getValue();

    case Array::INPUTTYPE_INT:
        return (float)i.getValue();

    case Array::INPUTTYPE_HALF:
        return h.to<float>();

    case Array::INPUTTYPE_DOUBLE:
        return (float)d.getValue();

    default:
        DE_ASSERT(false);
        return 0.0f;
    }
}

class RandomArrayGenerator
{
public:
    static char *generateArray(int seed, GLValue min, GLValue max, int count, int componentCount, int stride,
                               Array::InputType type);
    static char *generateQuads(int seed, int count, int componentCount, int offset, int stride,
                               Array::Primitive primitive, Array::InputType type, GLValue min, GLValue max,
                               float gridSize);
    static char *generatePerQuad(int seed, int count, int componentCount, int stride, Array::Primitive primitive,
                                 Array::InputType type, GLValue min, GLValue max);

private:
    template <typename T>
    static char *createQuads(int seed, int count, int componentCount, int offset, int stride,
                             Array::Primitive primitive, T min, T max, float gridSize);
    template <typename T>
    static char *createPerQuads(int seed, int count, int componentCount, int stride, Array::Primitive primitive, T min,
                                T max);
    static char *createQuadsPacked(int seed, int count, int componentCount, int offset, int stride,
                                   Array::Primitive primitive);
    static void setData(char *data, Array::InputType type, deRandom &rnd, GLValue min, GLValue max);
};

void RandomArrayGenerator::setData(char *data, Array::InputType type, deRandom &rnd, GLValue min, GLValue max)
{
    switch (type)
    {
    case Array::INPUTTYPE_FLOAT:
    {
        alignmentSafeAssignment<float>(data, getRandom<GLValue::Float>(rnd, min.fl, max.fl));
        break;
    }

    case Array::INPUTTYPE_DOUBLE:
    {
        alignmentSafeAssignment<double>(data, getRandom<GLValue::Float>(rnd, min.fl, max.fl));
        break;
    }

    case Array::INPUTTYPE_SHORT:
    {
        alignmentSafeAssignment<int16_t>(data, getRandom<GLValue::Short>(rnd, min.s, max.s));
        break;
    }

    case Array::INPUTTYPE_UNSIGNED_SHORT:
    {
        alignmentSafeAssignment<uint16_t>(data, getRandom<GLValue::Ushort>(rnd, min.us, max.us));
        break;
    }

    case Array::INPUTTYPE_BYTE:
    {
        alignmentSafeAssignment<int8_t>(data, getRandom<GLValue::Byte>(rnd, min.b, max.b));
        break;
    }

    case Array::INPUTTYPE_UNSIGNED_BYTE:
    {
        alignmentSafeAssignment<uint8_t>(data, getRandom<GLValue::Ubyte>(rnd, min.ub, max.ub));
        break;
    }

    case Array::INPUTTYPE_FIXED:
    {
        alignmentSafeAssignment<int32_t>(data, getRandom<GLValue::Fixed>(rnd, min.fi, max.fi));
        break;
    }

    case Array::INPUTTYPE_INT:
    {
        alignmentSafeAssignment<int32_t>(data, getRandom<GLValue::Int>(rnd, min.i, max.i));
        break;
    }

    case Array::INPUTTYPE_UNSIGNED_INT:
    {
        alignmentSafeAssignment<uint32_t>(data, getRandom<GLValue::Uint>(rnd, min.ui, max.ui));
        break;
    }

    case Array::INPUTTYPE_HALF:
    {
        alignmentSafeAssignment<deFloat16>(data, getRandom<GLValue::Half>(rnd, min.h, max.h).getValue());
        break;
    }

    default:
        DE_ASSERT(false);
        break;
    }
}

char *RandomArrayGenerator::generateArray(int seed, GLValue min, GLValue max, int count, int componentCount, int stride,
                                          Array::InputType type)
{
    char *data = NULL;

    deRandom rnd;
    deRandom_init(&rnd, seed);

    if (stride == 0)
        stride = componentCount * Array::inputTypeSize(type);

    data = new char[stride * count];

    for (int vertexNdx = 0; vertexNdx < count; vertexNdx++)
    {
        for (int componentNdx = 0; componentNdx < componentCount; componentNdx++)
        {
            setData(&(data[vertexNdx * stride + Array::inputTypeSize(type) * componentNdx]), type, rnd, min, max);
        }
    }

    return data;
}

char *RandomArrayGenerator::generateQuads(int seed, int count, int componentCount, int offset, int stride,
                                          Array::Primitive primitive, Array::InputType type, GLValue min, GLValue max,
                                          float gridSize)
{
    char *data = DE_NULL;

    switch (type)
    {
    case Array::INPUTTYPE_FLOAT:
        data = createQuads<GLValue::Float>(seed, count, componentCount, offset, stride, primitive, min.fl, max.fl,
                                           gridSize);
        break;

    case Array::INPUTTYPE_FIXED:
        data = createQuads<GLValue::Fixed>(seed, count, componentCount, offset, stride, primitive, min.fi, max.fi,
                                           gridSize);
        break;

    case Array::INPUTTYPE_DOUBLE:
        data = createQuads<GLValue::Double>(seed, count, componentCount, offset, stride, primitive, min.d, max.d,
                                            gridSize);
        break;

    case Array::INPUTTYPE_BYTE:
        data =
            createQuads<GLValue::Byte>(seed, count, componentCount, offset, stride, primitive, min.b, max.b, gridSize);
        break;

    case Array::INPUTTYPE_SHORT:
        data =
            createQuads<GLValue::Short>(seed, count, componentCount, offset, stride, primitive, min.s, max.s, gridSize);
        break;

    case Array::INPUTTYPE_UNSIGNED_BYTE:
        data = createQuads<GLValue::Ubyte>(seed, count, componentCount, offset, stride, primitive, min.ub, max.ub,
                                           gridSize);
        break;

    case Array::INPUTTYPE_UNSIGNED_SHORT:
        data = createQuads<GLValue::Ushort>(seed, count, componentCount, offset, stride, primitive, min.us, max.us,
                                            gridSize);
        break;

    case Array::INPUTTYPE_UNSIGNED_INT:
        data = createQuads<GLValue::Uint>(seed, count, componentCount, offset, stride, primitive, min.ui, max.ui,
                                          gridSize);
        break;

    case Array::INPUTTYPE_INT:
        data =
            createQuads<GLValue::Int>(seed, count, componentCount, offset, stride, primitive, min.i, max.i, gridSize);
        break;

    case Array::INPUTTYPE_HALF:
        data =
            createQuads<GLValue::Half>(seed, count, componentCount, offset, stride, primitive, min.h, max.h, gridSize);
        break;

    case Array::INPUTTYPE_INT_2_10_10_10:
    case Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10:
        data = createQuadsPacked(seed, count, componentCount, offset, stride, primitive);
        break;

    default:
        DE_ASSERT(false);
        break;
    }

    return data;
}

char *RandomArrayGenerator::createQuadsPacked(int seed, int count, int componentCount, int offset, int stride,
                                              Array::Primitive primitive)
{
    DE_ASSERT(componentCount == 4);
    DE_UNREF(componentCount);
    int quadStride = 0;

    if (stride == 0)
        stride = sizeof(uint32_t);

    switch (primitive)
    {
    case Array::PRIMITIVE_TRIANGLES:
        quadStride = stride * 6;
        break;

    default:
        DE_ASSERT(false);
        break;
    }

    char *const _data =
        new char[offset + quadStride * (count - 1) + stride * 5 +
                 componentCount *
                     Array::inputTypeSize(Array::INPUTTYPE_INT_2_10_10_10)]; // last element must be fully in the array
    char *const resultData = _data + offset;

    const uint32_t max  = 1024;
    const uint32_t min  = 10;
    const uint32_t max2 = 4;

    deRandom rnd;
    deRandom_init(&rnd, seed);

    switch (primitive)
    {
    case Array::PRIMITIVE_TRIANGLES:
    {
        for (int quadNdx = 0; quadNdx < count; quadNdx++)
        {
            uint32_t x1 = min + deRandom_getUint32(&rnd) % (max - min);
            uint32_t x2 = min + deRandom_getUint32(&rnd) % (max - x1);

            uint32_t y1 = min + deRandom_getUint32(&rnd) % (max - min);
            uint32_t y2 = min + deRandom_getUint32(&rnd) % (max - y1);

            uint32_t z = min + deRandom_getUint32(&rnd) % (max - min);
            uint32_t w = deRandom_getUint32(&rnd) % max2;

            uint32_t val1 = (w << 30) | (z << 20) | (y1 << 10) | x1;
            uint32_t val2 = (w << 30) | (z << 20) | (y1 << 10) | x2;
            uint32_t val3 = (w << 30) | (z << 20) | (y2 << 10) | x1;

            uint32_t val4 = (w << 30) | (z << 20) | (y2 << 10) | x1;
            uint32_t val5 = (w << 30) | (z << 20) | (y1 << 10) | x2;
            uint32_t val6 = (w << 30) | (z << 20) | (y2 << 10) | x2;

            alignmentSafeAssignment<uint32_t>(&(resultData[quadNdx * quadStride + stride * 0]), val1);
            alignmentSafeAssignment<uint32_t>(&(resultData[quadNdx * quadStride + stride * 1]), val2);
            alignmentSafeAssignment<uint32_t>(&(resultData[quadNdx * quadStride + stride * 2]), val3);
            alignmentSafeAssignment<uint32_t>(&(resultData[quadNdx * quadStride + stride * 3]), val4);
            alignmentSafeAssignment<uint32_t>(&(resultData[quadNdx * quadStride + stride * 4]), val5);
            alignmentSafeAssignment<uint32_t>(&(resultData[quadNdx * quadStride + stride * 5]), val6);
        }

        break;
    }

    default:
        DE_ASSERT(false);
        break;
    }

    return _data;
}

template <typename T>
T roundTo(const T &step, const T &value)
{
    return value - (value % step);
}

template <typename T>
char *RandomArrayGenerator::createQuads(int seed, int count, int componentCount, int offset, int stride,
                                        Array::Primitive primitive, T min, T max, float gridSize)
{
    int componentStride = sizeof(T);
    int quadStride      = 0;

    if (stride == 0)
        stride = componentCount * componentStride;

    DE_ASSERT(stride >= componentCount * componentStride);

    switch (primitive)
    {
    case Array::PRIMITIVE_TRIANGLES:
        quadStride = stride * 6;
        break;

    default:
        DE_ASSERT(false);
        break;
    }

    char *resultData = new char[offset + quadStride * count];
    char *_data      = resultData;
    resultData       = resultData + offset;

    deRandom rnd;
    deRandom_init(&rnd, seed);

    switch (primitive)
    {
    case Array::PRIMITIVE_TRIANGLES:
    {
        const T minQuadSize = T::fromFloat(deFloatAbs(max.template to<float>() - min.template to<float>()) * gridSize);
        const T minDiff     = minValue<T>() > minQuadSize ? minValue<T>() : minQuadSize;
        const T maxRounded  = roundTo(minDiff, max);

        for (int quadNdx = 0; quadNdx < count; ++quadNdx)
        {
            T x1, x2;
            T y1, y2;
            T z, w;

            x1 = roundTo(minDiff, getRandom<T>(rnd, min, maxRounded - minDiff));
            x2 = roundTo(minDiff, getRandom<T>(rnd, x1 + minDiff, maxRounded));

            y1 = roundTo(minDiff, getRandom<T>(rnd, min, maxRounded - minDiff));
            y2 = roundTo(minDiff, getRandom<T>(rnd, y1 + minDiff, maxRounded));

            // Make sure the rounding doesn't drop the result below the original range of the random function.
            if (x2 < x1 + minDiff)
                x2 = x1 + minDiff;
            if (y2 < y1 + minDiff)
                y2 = y1 + minDiff;

            z = (componentCount > 2) ? roundTo(minDiff, (getRandom<T>(rnd, min, max))) : (T::create(0));
            w = (componentCount > 3) ? roundTo(minDiff, (getRandom<T>(rnd, min, max))) : (T::create(1));

            // Make sure the quad is not too thin.
            DE_ASSERT(
                (deFloatAbs(x2.template to<float>() - x1.template to<float>()) >=
                 minDiff.template to<float>() * 0.8f) &&
                (deFloatAbs(y2.template to<float>() - y1.template to<float>()) >= minDiff.template to<float>() * 0.8f));

            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride]), x1);
            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + componentStride]), y1);

            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride]), x2);
            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride + componentStride]), y1);

            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 2]), x1);
            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 2 + componentStride]), y2);

            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 3]), x1);
            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 3 + componentStride]), y2);

            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 4]), x2);
            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 4 + componentStride]), y1);

            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 5]), x2);
            alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * 5 + componentStride]), y2);

            if (componentCount > 2)
            {
                for (int i = 0; i < 6; i++)
                    alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * i + componentStride * 2]),
                                               z);
            }

            if (componentCount > 3)
            {
                for (int i = 0; i < 6; i++)
                    alignmentSafeAssignment<T>(&(resultData[quadNdx * quadStride + stride * i + componentStride * 3]),
                                               w);
            }
        }

        break;
    }

    default:
        DE_ASSERT(false);
        break;
    }

    return _data;
}

char *RandomArrayGenerator::generatePerQuad(int seed, int count, int componentCount, int stride,
                                            Array::Primitive primitive, Array::InputType type, GLValue min, GLValue max)
{
    char *data = DE_NULL;

    switch (type)
    {
    case Array::INPUTTYPE_FLOAT:
        data = createPerQuads<GLValue::Float>(seed, count, componentCount, stride, primitive, min.fl, max.fl);
        break;

    case Array::INPUTTYPE_FIXED:
        data = createPerQuads<GLValue::Fixed>(seed, count, componentCount, stride, primitive, min.fi, max.fi);
        break;

    case Array::INPUTTYPE_DOUBLE:
        data = createPerQuads<GLValue::Double>(seed, count, componentCount, stride, primitive, min.d, max.d);
        break;

    case Array::INPUTTYPE_BYTE:
        data = createPerQuads<GLValue::Byte>(seed, count, componentCount, stride, primitive, min.b, max.b);
        break;

    case Array::INPUTTYPE_SHORT:
        data = createPerQuads<GLValue::Short>(seed, count, componentCount, stride, primitive, min.s, max.s);
        break;

    case Array::INPUTTYPE_UNSIGNED_BYTE:
        data = createPerQuads<GLValue::Ubyte>(seed, count, componentCount, stride, primitive, min.ub, max.ub);
        break;

    case Array::INPUTTYPE_UNSIGNED_SHORT:
        data = createPerQuads<GLValue::Ushort>(seed, count, componentCount, stride, primitive, min.us, max.us);
        break;

    case Array::INPUTTYPE_UNSIGNED_INT:
        data = createPerQuads<GLValue::Uint>(seed, count, componentCount, stride, primitive, min.ui, max.ui);
        break;

    case Array::INPUTTYPE_INT:
        data = createPerQuads<GLValue::Int>(seed, count, componentCount, stride, primitive, min.i, max.i);
        break;

    case Array::INPUTTYPE_HALF:
        data = createPerQuads<GLValue::Half>(seed, count, componentCount, stride, primitive, min.h, max.h);
        break;

    default:
        DE_ASSERT(false);
        break;
    }

    return data;
}

template <typename T>
char *RandomArrayGenerator::createPerQuads(int seed, int count, int componentCount, int stride,
                                           Array::Primitive primitive, T min, T max)
{
    deRandom rnd;
    deRandom_init(&rnd, seed);

    int componentStride = sizeof(T);

    if (stride == 0)
        stride = componentStride * componentCount;

    int quadStride = 0;

    switch (primitive)
    {
    case Array::PRIMITIVE_TRIANGLES:
        quadStride = stride * 6;
        break;

    default:
        DE_ASSERT(false);
        break;
    }

    char *data = new char[count * quadStride];

    for (int quadNdx = 0; quadNdx < count; quadNdx++)
    {
        for (int componentNdx = 0; componentNdx < componentCount; componentNdx++)
        {
            T val = getRandom<T>(rnd, min, max);

            alignmentSafeAssignment<T>(data + quadNdx * quadStride + stride * 0 + componentStride * componentNdx, val);
            alignmentSafeAssignment<T>(data + quadNdx * quadStride + stride * 1 + componentStride * componentNdx, val);
            alignmentSafeAssignment<T>(data + quadNdx * quadStride + stride * 2 + componentStride * componentNdx, val);
            alignmentSafeAssignment<T>(data + quadNdx * quadStride + stride * 3 + componentStride * componentNdx, val);
            alignmentSafeAssignment<T>(data + quadNdx * quadStride + stride * 4 + componentStride * componentNdx, val);
            alignmentSafeAssignment<T>(data + quadNdx * quadStride + stride * 5 + componentStride * componentNdx, val);
        }
    }

    return data;
}

// VertexArrayTest

VertexArrayTest::VertexArrayTest(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const char *name,
                                 const char *desc)
    : TestCase(testCtx, name, desc)
    , m_renderCtx(renderCtx)
    , m_refBuffers(DE_NULL)
    , m_refContext(DE_NULL)
    , m_glesContext(DE_NULL)
    , m_glArrayPack(DE_NULL)
    , m_rrArrayPack(DE_NULL)
    , m_isOk(false)
    , m_maxDiffRed(
          deCeilFloatToInt32(256.0f * (2.0f / (float)(1 << m_renderCtx.getRenderTarget().getPixelFormat().redBits))))
    , m_maxDiffGreen(
          deCeilFloatToInt32(256.0f * (2.0f / (float)(1 << m_renderCtx.getRenderTarget().getPixelFormat().greenBits))))
    , m_maxDiffBlue(
          deCeilFloatToInt32(256.0f * (2.0f / (float)(1 << m_renderCtx.getRenderTarget().getPixelFormat().blueBits))))
{
}

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

void VertexArrayTest::init(void)
{
    const int renderTargetWidth  = de::min(512, m_renderCtx.getRenderTarget().getWidth());
    const int renderTargetHeight = de::min(512, m_renderCtx.getRenderTarget().getHeight());
    sglr::ReferenceContextLimits limits(m_renderCtx);

    m_glesContext =
        new sglr::GLContext(m_renderCtx, m_testCtx.getLog(), sglr::GLCONTEXT_LOG_CALLS | sglr::GLCONTEXT_LOG_PROGRAMS,
                            tcu::IVec4(0, 0, renderTargetWidth, renderTargetHeight));

    m_refBuffers = new sglr::ReferenceContextBuffers(m_renderCtx.getRenderTarget().getPixelFormat(), 0, 0,
                                                     renderTargetWidth, renderTargetHeight);
    m_refContext = new sglr::ReferenceContext(limits, m_refBuffers->getColorbuffer(), m_refBuffers->getDepthbuffer(),
                                              m_refBuffers->getStencilbuffer());

    m_glArrayPack = new ContextArrayPack(m_renderCtx, *m_glesContext);
    m_rrArrayPack = new ContextArrayPack(m_renderCtx, *m_refContext);
}

void VertexArrayTest::deinit(void)
{
    delete m_glArrayPack;
    delete m_rrArrayPack;
    delete m_refBuffers;
    delete m_refContext;
    delete m_glesContext;

    m_glArrayPack = DE_NULL;
    m_rrArrayPack = DE_NULL;
    m_refBuffers  = DE_NULL;
    m_refContext  = DE_NULL;
    m_glesContext = DE_NULL;
}

void VertexArrayTest::compare(void)
{
    const tcu::Surface &ref    = m_rrArrayPack->getSurface();
    const tcu::Surface &screen = m_glArrayPack->getSurface();

    if (m_renderCtx.getRenderTarget().getNumSamples() > 1)
    {
        // \todo [mika] Improve compare when using multisampling
        m_testCtx.getLog() << tcu::TestLog::Message
                           << "Warning: Comparision of result from multisample render targets are not as stricts as "
                              "without multisampling. Might produce false positives!"
                           << tcu::TestLog::EndMessage;
        m_isOk = tcu::fuzzyCompare(m_testCtx.getLog(), "Compare Results", "Compare Results", ref.getAccess(),
                                   screen.getAccess(), 1.5f, tcu::COMPARE_LOG_RESULT);
    }
    else
    {
        tcu::RGBA threshold(m_maxDiffRed, m_maxDiffGreen, m_maxDiffBlue, 255);
        tcu::Surface error(ref.getWidth(), ref.getHeight());

        m_isOk = true;

        for (int y = 0; y < ref.getHeight(); y++)
        {
            for (int x = 0; x < ref.getWidth(); x++)
            {
                tcu::RGBA refPixel    = ref.getPixel(x, y);
                tcu::RGBA screenPixel = screen.getPixel(x, y);
                bool isOkPixel        = false;

                if (y == 0 || y + 1 == ref.getHeight() || x == 0 || x + 1 == ref.getWidth())
                {
                    // Don't check borders since the pixel neighborhood is undefined
                    error.setPixel(x, y,
                                   tcu::RGBA(screenPixel.getRed(), (screenPixel.getGreen() + 255) / 2,
                                             screenPixel.getBlue(), 255));
                    continue;
                }

                // Don't do comparisons for this pixel if it belongs to a one-pixel-thin part (i.e. it doesn't have similar-color neighbors in both x and y directions) in both result and reference.
                // This fixes some false negatives.
                bool refThin = (!tcu::compareThreshold(refPixel, ref.getPixel(x - 1, y), threshold) &&
                                !tcu::compareThreshold(refPixel, ref.getPixel(x + 1, y), threshold)) ||
                               (!tcu::compareThreshold(refPixel, ref.getPixel(x, y - 1), threshold) &&
                                !tcu::compareThreshold(refPixel, ref.getPixel(x, y + 1), threshold));
                bool screenThin = (!tcu::compareThreshold(screenPixel, screen.getPixel(x - 1, y), threshold) &&
                                   !tcu::compareThreshold(screenPixel, screen.getPixel(x + 1, y), threshold)) ||
                                  (!tcu::compareThreshold(screenPixel, screen.getPixel(x, y - 1), threshold) &&
                                   !tcu::compareThreshold(screenPixel, screen.getPixel(x, y + 1), threshold));

                if (refThin && screenThin)
                    isOkPixel = true;
                else
                {
                    for (int dy = -1; dy < 2 && !isOkPixel; dy++)
                    {
                        for (int dx = -1; dx < 2 && !isOkPixel; dx++)
                        {
                            // Check reference pixel against screen pixel
                            {
                                tcu::RGBA screenCmpPixel = screen.getPixel(x + dx, y + dy);
                                uint8_t r = (uint8_t)deAbs32(refPixel.getRed() - screenCmpPixel.getRed());
                                uint8_t g = (uint8_t)deAbs32(refPixel.getGreen() - screenCmpPixel.getGreen());
                                uint8_t b = (uint8_t)deAbs32(refPixel.getBlue() - screenCmpPixel.getBlue());

                                if (r <= m_maxDiffRed && g <= m_maxDiffGreen && b <= m_maxDiffBlue)
                                    isOkPixel = true;
                            }

                            // Check screen pixels against reference pixel
                            {
                                tcu::RGBA refCmpPixel = ref.getPixel(x + dx, y + dy);
                                uint8_t r             = (uint8_t)deAbs32(refCmpPixel.getRed() - screenPixel.getRed());
                                uint8_t g = (uint8_t)deAbs32(refCmpPixel.getGreen() - screenPixel.getGreen());
                                uint8_t b = (uint8_t)deAbs32(refCmpPixel.getBlue() - screenPixel.getBlue());

                                if (r <= m_maxDiffRed && g <= m_maxDiffGreen && b <= m_maxDiffBlue)
                                    isOkPixel = true;
                            }
                        }
                    }
                }

                if (isOkPixel)
                    error.setPixel(x, y,
                                   tcu::RGBA(screen.getPixel(x, y).getRed(),
                                             (screen.getPixel(x, y).getGreen() + 255) / 2,
                                             screen.getPixel(x, y).getBlue(), 255));
                else
                {
                    error.setPixel(x, y, tcu::RGBA(255, 0, 0, 255));
                    m_isOk = false;
                }
            }
        }

        tcu::TestLog &log = m_testCtx.getLog();
        if (!m_isOk)
        {
            log << TestLog::Message << "Image comparison failed, threshold = (" << m_maxDiffRed << ", "
                << m_maxDiffGreen << ", " << m_maxDiffBlue << ")" << TestLog::EndMessage;
            log << TestLog::ImageSet("Compare result", "Result of rendering")
                << TestLog::Image("Result", "Result", screen) << TestLog::Image("Reference", "Reference", ref)
                << TestLog::Image("ErrorMask", "Error mask", error) << TestLog::EndImageSet;
        }
        else
        {
            log << TestLog::ImageSet("Compare result", "Result of rendering")
                << TestLog::Image("Result", "Result", screen) << TestLog::EndImageSet;
        }
    }
}

// MultiVertexArrayTest

MultiVertexArrayTest::Spec::ArraySpec::ArraySpec(Array::InputType inputType_, Array::OutputType outputType_,
                                                 Array::Storage storage_, Array::Usage usage_, int componentCount_,
                                                 int offset_, int stride_, bool normalize_, GLValue min_, GLValue max_)
    : inputType(inputType_)
    , outputType(outputType_)
    , storage(storage_)
    , usage(usage_)
    , componentCount(componentCount_)
    , offset(offset_)
    , stride(stride_)
    , normalize(normalize_)
    , min(min_)
    , max(max_)
{
}

std::string MultiVertexArrayTest::Spec::getName(void) const
{
    std::stringstream name;

    for (size_t ndx = 0; ndx < arrays.size(); ++ndx)
    {
        const ArraySpec &array = arrays[ndx];

        if (arrays.size() > 1)
            name << "array" << ndx << "_";

        name << Array::storageToString(array.storage) << "_" << array.offset << "_" << array.stride << "_"
             << Array::inputTypeToString((Array::InputType)array.inputType);
        if (array.inputType != Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 &&
            array.inputType != Array::INPUTTYPE_INT_2_10_10_10)
            name << array.componentCount;
        name << "_" << (array.normalize ? "normalized_" : "") << Array::outputTypeToString(array.outputType) << "_"
             << Array::usageTypeToString(array.usage) << "_";
    }

    if (first)
        name << "first" << first << "_";

    switch (primitive)
    {
    case Array::PRIMITIVE_TRIANGLES:
        name << "quads_";
        break;
    case Array::PRIMITIVE_POINTS:
        name << "points_";
        break;

    default:
        DE_ASSERT(false);
        break;
    }

    name << drawCount;

    return name.str();
}

std::string MultiVertexArrayTest::Spec::getDesc(void) const
{
    std::stringstream desc;

    for (size_t ndx = 0; ndx < arrays.size(); ++ndx)
    {
        const ArraySpec &array = arrays[ndx];

        desc << "Array " << ndx << ": "
             << "Storage in " << Array::storageToString(array.storage) << ", "
             << "stride " << array.stride << ", "
             << "input datatype " << Array::inputTypeToString((Array::InputType)array.inputType) << ", "
             << "input component count " << array.componentCount << ", " << (array.normalize ? "normalized, " : "")
             << "used as " << Array::outputTypeToString(array.outputType) << ", ";
    }

    desc << "drawArrays(), "
         << "first " << first << ", " << drawCount;

    switch (primitive)
    {
    case Array::PRIMITIVE_TRIANGLES:
        desc << "quads ";
        break;
    case Array::PRIMITIVE_POINTS:
        desc << "points";
        break;

    default:
        DE_ASSERT(false);
        break;
    }

    return desc.str();
}

MultiVertexArrayTest::MultiVertexArrayTest(tcu::TestContext &testCtx, glu::RenderContext &renderCtx, const Spec &spec,
                                           const char *name, const char *desc)
    : VertexArrayTest(testCtx, renderCtx, name, desc)
    , m_spec(spec)
    , m_iteration(0)
{
}

MultiVertexArrayTest::~MultiVertexArrayTest(void)
{
}

MultiVertexArrayTest::IterateResult MultiVertexArrayTest::iterate(void)
{
    if (m_iteration == 0)
    {
        const size_t primitiveSize = (m_spec.primitive == Array::PRIMITIVE_TRIANGLES) ?
                                         (6) :
                                         (1); // in non-indexed draw Triangles means rectangles
        float coordScale           = 1.0f;
        float colorScale           = 1.0f;
        const bool useVao          = m_renderCtx.getType().getProfile() == glu::PROFILE_CORE;

        // Log info
        m_testCtx.getLog() << TestLog::Message << m_spec.getDesc() << TestLog::EndMessage;

        // Color and Coord scale
        {
            // First array is always position
            {
                Spec::ArraySpec arraySpec = m_spec.arrays[0];
                if (arraySpec.inputType == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10)
                {
                    if (arraySpec.normalize)
                        coordScale = 1.0f;
                    else
                        coordScale = 1.0 / 1024.0;
                }
                else if (arraySpec.inputType == Array::INPUTTYPE_INT_2_10_10_10)
                {
                    if (arraySpec.normalize)
                        coordScale = 1.0f;
                    else
                        coordScale = 1.0 / 512.0;
                }
                else
                    coordScale = (arraySpec.normalize && !inputTypeIsFloatType(arraySpec.inputType) ?
                                      1.0f :
                                      float(0.9 / double(arraySpec.max.toFloat())));

                if (arraySpec.outputType == Array::OUTPUTTYPE_VEC3 || arraySpec.outputType == Array::OUTPUTTYPE_VEC4 ||
                    arraySpec.outputType == Array::OUTPUTTYPE_IVEC3 ||
                    arraySpec.outputType == Array::OUTPUTTYPE_IVEC4 ||
                    arraySpec.outputType == Array::OUTPUTTYPE_UVEC3 || arraySpec.outputType == Array::OUTPUTTYPE_UVEC4)
                    coordScale = coordScale * 0.5f;
            }

            // And other arrays are color-like
            for (int arrayNdx = 1; arrayNdx < (int)m_spec.arrays.size(); arrayNdx++)
            {
                Spec::ArraySpec arraySpec = m_spec.arrays[arrayNdx];

                colorScale *= (arraySpec.normalize && !inputTypeIsFloatType(arraySpec.inputType) ?
                                   1.0f :
                                   float(1.0 / double(arraySpec.max.toFloat())));
                if (arraySpec.outputType == Array::OUTPUTTYPE_VEC4)
                    colorScale *= (arraySpec.normalize && !inputTypeIsFloatType(arraySpec.inputType) ?
                                       1.0f :
                                       float(1.0 / double(arraySpec.max.toFloat())));
            }
        }

        // Data
        for (int arrayNdx = 0; arrayNdx < (int)m_spec.arrays.size(); arrayNdx++)
        {
            Spec::ArraySpec arraySpec = m_spec.arrays[arrayNdx];
            const int seed = int(arraySpec.inputType) + 10 * int(arraySpec.outputType) + 100 * int(arraySpec.storage) +
                             1000 * int(m_spec.primitive) + 10000 * int(arraySpec.usage) + int(m_spec.drawCount) +
                             12 * int(arraySpec.componentCount) + int(arraySpec.stride) + int(arraySpec.normalize);
            const char *data        = DE_NULL;
            const size_t stride     = (arraySpec.stride == 0) ?
                                          (arraySpec.componentCount * Array::inputTypeSize(arraySpec.inputType)) :
                                          (arraySpec.stride);
            const size_t bufferSize = arraySpec.offset + stride * (m_spec.drawCount * primitiveSize - 1) +
                                      arraySpec.componentCount * Array::inputTypeSize(arraySpec.inputType);
            // Snap values to at least 3x3 grid
            const float gridSize = 3.0f / (float)(de::min(m_renderCtx.getRenderTarget().getWidth(),
                                                          m_renderCtx.getRenderTarget().getHeight()) -
                                                  1);

            switch (m_spec.primitive)
            {
                //            case Array::PRIMITIVE_POINTS:
                // data = RandomArrayGenerator::generateArray(seed, arraySpec.min, arraySpec.max, arraySpec.count, arraySpec.componentCount, arraySpec.stride, arraySpec.inputType);
                // break;
            case Array::PRIMITIVE_TRIANGLES:
                if (arrayNdx == 0)
                {
                    data = RandomArrayGenerator::generateQuads(
                        seed, m_spec.drawCount, arraySpec.componentCount, arraySpec.offset, arraySpec.stride,
                        m_spec.primitive, arraySpec.inputType, arraySpec.min, arraySpec.max, gridSize);
                }
                else
                {
                    DE_ASSERT(arraySpec.offset == 0); // \note [jarkko] it just hasn't been implemented
                    data = RandomArrayGenerator::generatePerQuad(seed, m_spec.drawCount, arraySpec.componentCount,
                                                                 arraySpec.stride, m_spec.primitive,
                                                                 arraySpec.inputType, arraySpec.min, arraySpec.max);
                }
                break;

            default:
                DE_ASSERT(false);
                break;
            }

            m_glArrayPack->newArray(arraySpec.storage);
            m_rrArrayPack->newArray(arraySpec.storage);

            m_glArrayPack->getArray(arrayNdx)->data(Array::TARGET_ARRAY, (int)bufferSize, data, arraySpec.usage);
            m_rrArrayPack->getArray(arrayNdx)->data(Array::TARGET_ARRAY, (int)bufferSize, data, arraySpec.usage);

            m_glArrayPack->getArray(arrayNdx)->bind(arrayNdx, arraySpec.offset, arraySpec.componentCount,
                                                    arraySpec.inputType, arraySpec.outputType, arraySpec.normalize,
                                                    arraySpec.stride);
            m_rrArrayPack->getArray(arrayNdx)->bind(arrayNdx, arraySpec.offset, arraySpec.componentCount,
                                                    arraySpec.inputType, arraySpec.outputType, arraySpec.normalize,
                                                    arraySpec.stride);

            delete[] data;
        }

        try
        {
            m_glArrayPack->render(m_spec.primitive, m_spec.first, m_spec.drawCount * (int)primitiveSize, useVao,
                                  coordScale, colorScale);
            m_testCtx.touchWatchdog();
            m_rrArrayPack->render(m_spec.primitive, m_spec.first, m_spec.drawCount * (int)primitiveSize, useVao,
                                  coordScale, colorScale);
        }
        catch (glu::Error &err)
        {
            // GL Errors are ok if the mode is not properly aligned

            m_testCtx.getLog() << TestLog::Message << "Got error: " << err.what() << TestLog::EndMessage;

            if (isUnalignedBufferOffsetTest())
                m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned buffers.");
            else if (isUnalignedBufferStrideTest())
                m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned stride.");
            else
                throw;

            return STOP;
        }

        m_iteration++;
        return CONTINUE;
    }
    else if (m_iteration == 1)
    {
        compare();

        if (m_isOk)
        {
            m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
        }
        else
        {
            if (isUnalignedBufferOffsetTest())
                m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned buffers.");
            else if (isUnalignedBufferStrideTest())
                m_testCtx.setTestResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned stride.");
            else
                m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed.");
        }

        m_iteration++;
        return STOP;
    }
    else
    {
        DE_ASSERT(false);
        return STOP;
    }
}

bool MultiVertexArrayTest::isUnalignedBufferOffsetTest(void) const
{
    // Buffer offsets should be data type size aligned
    for (size_t i = 0; i < m_spec.arrays.size(); ++i)
    {
        if (m_spec.arrays[i].storage == Array::STORAGE_BUFFER)
        {
            const bool inputTypePacked = m_spec.arrays[i].inputType == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 ||
                                         m_spec.arrays[i].inputType == Array::INPUTTYPE_INT_2_10_10_10;

            int dataTypeSize = Array::inputTypeSize(m_spec.arrays[i].inputType);
            if (inputTypePacked)
                dataTypeSize = 4;

            if (m_spec.arrays[i].offset % dataTypeSize != 0)
                return true;
        }
    }

    return false;
}

bool MultiVertexArrayTest::isUnalignedBufferStrideTest(void) const
{
    // Buffer strides should be data type size aligned
    for (size_t i = 0; i < m_spec.arrays.size(); ++i)
    {
        if (m_spec.arrays[i].storage == Array::STORAGE_BUFFER)
        {
            const bool inputTypePacked = m_spec.arrays[i].inputType == Array::INPUTTYPE_UNSIGNED_INT_2_10_10_10 ||
                                         m_spec.arrays[i].inputType == Array::INPUTTYPE_INT_2_10_10_10;

            int dataTypeSize = Array::inputTypeSize(m_spec.arrays[i].inputType);
            if (inputTypePacked)
                dataTypeSize = 4;

            if (m_spec.arrays[i].stride % dataTypeSize != 0)
                return true;
        }
    }

    return false;
}

} // namespace gls
} // namespace deqp