/*-------------------------------------------------------------------------
 * drawElements Quality Program Reference Renderer
 * -----------------------------------------------
 *
 * 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 attribute fetch.
 *//*--------------------------------------------------------------------*/

#include "rrVertexAttrib.hpp"
#include "tcuFloat.hpp"
#include "deInt32.h"
#include "deMemory.h"

namespace rr
{

namespace
{

struct NormalOrder
{
    enum
    {
        T0 = 0,
        T1 = 1,
        T2 = 2,
        T3 = 3,
    };
};

struct BGRAOrder
{
    enum
    {
        T0 = 2,
        T1 = 1,
        T2 = 0,
        T3 = 3,
    };
};

// readers

template <typename SrcScalarType, typename DstScalarType, typename Order>
inline void readOrder(typename tcu::Vector<DstScalarType, 4> &dst, const int size, const void *ptr)
{
    SrcScalarType aligned[4];
    deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));

    dst[Order::T0] = DstScalarType(aligned[0]);
    if (size >= 2)
        dst[Order::T1] = DstScalarType(aligned[1]);
    if (size >= 3)
        dst[Order::T2] = DstScalarType(aligned[2]);
    if (size >= 4)
        dst[Order::T3] = DstScalarType(aligned[3]);
}

template <typename SrcScalarType, typename Order>
inline void readUnormOrder(tcu::Vec4 &dst, const int size, const void *ptr)
{
    const uint32_t range = (uint32_t)((1ull << (sizeof(SrcScalarType) * 8)) - 1);

    SrcScalarType aligned[4];
    deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));

    dst[Order::T0] = float(aligned[0]) / float(range);
    if (size >= 2)
        dst[Order::T1] = float(aligned[1]) / float(range);
    if (size >= 3)
        dst[Order::T2] = float(aligned[2]) / float(range);
    if (size >= 4)
        dst[Order::T3] = float(aligned[3]) / float(range);
}

template <typename SrcScalarType>
inline void readSnormClamp(tcu::Vec4 &dst, const int size, const void *ptr)
{
    // Clamped formats, GLES3-style conversion: max{c / (2^(b-1) - 1), -1 }
    const uint32_t range = (uint32_t)((1ull << (sizeof(SrcScalarType) * 8 - 1)) - 1);

    SrcScalarType aligned[4];
    deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));

    dst[0] = de::max(-1.0f, float(aligned[0]) / float(range));
    if (size >= 2)
        dst[1] = de::max(-1.0f, float(aligned[1]) / float(range));
    if (size >= 3)
        dst[2] = de::max(-1.0f, float(aligned[2]) / float(range));
    if (size >= 4)
        dst[3] = de::max(-1.0f, float(aligned[3]) / float(range));
}

template <typename SrcScalarType>
inline void readSnormScale(tcu::Vec4 &dst, const int size, const void *ptr)
{
    // Scaled formats, GLES2-style conversion: (2c + 1) / (2^b - 1)
    const uint32_t range = (uint32_t)((1ull << (sizeof(SrcScalarType) * 8)) - 1);

    SrcScalarType aligned[4];
    deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));

    dst[0] = (float(aligned[0]) * 2.0f + 1.0f) / float(range);
    if (size >= 2)
        dst[1] = (float(aligned[1]) * 2.0f + 1.0f) / float(range);
    if (size >= 3)
        dst[2] = (float(aligned[2]) * 2.0f + 1.0f) / float(range);
    if (size >= 4)
        dst[3] = (float(aligned[3]) * 2.0f + 1.0f) / float(range);
}

inline void readHalf(tcu::Vec4 &dst, const int size, const void *ptr)
{
    uint16_t aligned[4];
    deMemcpy(aligned, ptr, size * sizeof(uint16_t));

    dst[0] = tcu::Float16(aligned[0]).asFloat();
    if (size >= 2)
        dst[1] = tcu::Float16(aligned[1]).asFloat();
    if (size >= 3)
        dst[2] = tcu::Float16(aligned[2]).asFloat();
    if (size >= 4)
        dst[3] = tcu::Float16(aligned[3]).asFloat();
}

inline void readFixed(tcu::Vec4 &dst, const int size, const void *ptr)
{
    int32_t aligned[4];
    deMemcpy(aligned, ptr, size * sizeof(int32_t));

    dst[0] = float(aligned[0]) / float(1 << 16);
    if (size >= 2)
        dst[1] = float(aligned[1]) / float(1 << 16);
    if (size >= 3)
        dst[2] = float(aligned[2]) / float(1 << 16);
    if (size >= 4)
        dst[3] = float(aligned[3]) / float(1 << 16);
}

inline void readDouble(tcu::Vec4 &dst, const int size, const void *ptr)
{
    double aligned[4];
    deMemcpy(aligned, ptr, size * sizeof(double));

    dst[0] = float(aligned[0]);
    if (size >= 2)
        dst[1] = float(aligned[1]);
    if (size >= 3)
        dst[2] = float(aligned[2]);
    if (size >= 4)
        dst[3] = float(aligned[3]);
}

template <int integerLen>
inline int32_t extendSign(uint32_t integer)
{
    return uint32_t(0 - int32_t((integer & (1 << (integerLen - 1))) << 1)) | integer;
}

template <typename DstScalarType>
inline void readUint2101010Rev(typename tcu::Vector<DstScalarType, 4> &dst, const int size, const void *ptr)
{
    uint32_t aligned;
    deMemcpy(&aligned, ptr, sizeof(uint32_t));

    dst[0] = DstScalarType((aligned >> 0) & ((1 << 10) - 1));
    if (size >= 2)
        dst[1] = DstScalarType((aligned >> 10) & ((1 << 10) - 1));
    if (size >= 3)
        dst[2] = DstScalarType((aligned >> 20) & ((1 << 10) - 1));
    if (size >= 4)
        dst[3] = DstScalarType((aligned >> 30) & ((1 << 2) - 1));
}

template <typename DstScalarType>
inline void readInt2101010Rev(typename tcu::Vector<DstScalarType, 4> &dst, const int size, const void *ptr)
{
    uint32_t aligned;
    deMemcpy(&aligned, ptr, sizeof(uint32_t));

    dst[0] = (DstScalarType)extendSign<10>((aligned >> 0) & ((1 << 10) - 1));
    if (size >= 2)
        dst[1] = (DstScalarType)extendSign<10>((aligned >> 10) & ((1 << 10) - 1));
    if (size >= 3)
        dst[2] = (DstScalarType)extendSign<10>((aligned >> 20) & ((1 << 10) - 1));
    if (size >= 4)
        dst[3] = (DstScalarType)extendSign<2>((aligned >> 30) & ((1 << 2) - 1));
}

template <typename Order>
inline void readUnorm2101010RevOrder(tcu::Vec4 &dst, const int size, const void *ptr)
{
    const uint32_t range10 = (uint32_t)((1ull << 10) - 1);
    const uint32_t range2  = (uint32_t)((1ull << 2) - 1);

    uint32_t aligned;
    deMemcpy(&aligned, ptr, sizeof(uint32_t));

    dst[Order::T0] = float((aligned >> 0) & ((1 << 10) - 1)) / float(range10);
    if (size >= 2)
        dst[Order::T1] = float((aligned >> 10) & ((1 << 10) - 1)) / float(range10);
    if (size >= 3)
        dst[Order::T2] = float((aligned >> 20) & ((1 << 10) - 1)) / float(range10);
    if (size >= 4)
        dst[Order::T3] = float((aligned >> 30) & ((1 << 2) - 1)) / float(range2);
}

template <typename Order>
inline void readSnorm2101010RevClampOrder(tcu::Vec4 &dst, const int size, const void *ptr)
{
    // Clamped formats, GLES3-style conversion: max{c / (2^(b-1) - 1), -1 }
    const uint32_t range10 = (uint32_t)((1ull << (10 - 1)) - 1);
    const uint32_t range2  = (uint32_t)((1ull << (2 - 1)) - 1);

    uint32_t aligned;
    deMemcpy(&aligned, ptr, sizeof(uint32_t));

    dst[Order::T0] = de::max(-1.0f, float(extendSign<10>((aligned >> 0) & ((1 << 10) - 1))) / float(range10));
    if (size >= 2)
        dst[Order::T1] = de::max(-1.0f, float(extendSign<10>((aligned >> 10) & ((1 << 10) - 1))) / float(range10));
    if (size >= 3)
        dst[Order::T2] = de::max(-1.0f, float(extendSign<10>((aligned >> 20) & ((1 << 10) - 1))) / float(range10));
    if (size >= 4)
        dst[Order::T3] = de::max(-1.0f, float(extendSign<2>((aligned >> 30) & ((1 << 2) - 1))) / float(range2));
}

template <typename Order>
inline void readSnorm2101010RevScaleOrder(tcu::Vec4 &dst, const int size, const void *ptr)
{
    // Scaled formats, GLES2-style conversion: (2c + 1) / (2^b - 1)
    const uint32_t range10 = (uint32_t)((1ull << 10) - 1);
    const uint32_t range2  = (uint32_t)((1ull << 2) - 1);

    uint32_t aligned;
    deMemcpy(&aligned, ptr, sizeof(uint32_t));

    dst[Order::T0] = (float(extendSign<10>((aligned >> 0) & ((1 << 10) - 1))) * 2.0f + 1.0f) / float(range10);
    if (size >= 2)
        dst[Order::T1] = (float(extendSign<10>((aligned >> 10) & ((1 << 10) - 1))) * 2.0f + 1.0f) / float(range10);
    if (size >= 3)
        dst[Order::T2] = (float(extendSign<10>((aligned >> 20) & ((1 << 10) - 1))) * 2.0f + 1.0f) / float(range10);
    if (size >= 4)
        dst[Order::T3] = (float(extendSign<2>((aligned >> 30) & ((1 << 2) - 1))) * 2.0f + 1.0f) / float(range2);
}

// ordered readers

template <typename SrcScalarType, typename DstScalarType>
inline void read(typename tcu::Vector<DstScalarType, 4> &dst, const int size, const void *ptr)
{
    readOrder<SrcScalarType, DstScalarType, NormalOrder>(dst, size, ptr);
}

template <typename SrcScalarType>
inline void readUnorm(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readUnormOrder<SrcScalarType, NormalOrder>(dst, size, ptr);
}

template <typename SrcScalarType>
inline void readUnormBGRA(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readUnormOrder<SrcScalarType, BGRAOrder>(dst, size, ptr);
}

inline void readUnorm2101010Rev(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readUnorm2101010RevOrder<NormalOrder>(dst, size, ptr);
}

inline void readUnorm2101010RevBGRA(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readUnorm2101010RevOrder<BGRAOrder>(dst, size, ptr);
}

inline void readSnorm2101010RevClamp(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readSnorm2101010RevClampOrder<NormalOrder>(dst, size, ptr);
}

inline void readSnorm2101010RevClampBGRA(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readSnorm2101010RevClampOrder<BGRAOrder>(dst, size, ptr);
}

inline void readSnorm2101010RevScale(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readSnorm2101010RevScaleOrder<NormalOrder>(dst, size, ptr);
}

inline void readSnorm2101010RevScaleBGRA(tcu::Vec4 &dst, const int size, const void *ptr)
{
    readSnorm2101010RevScaleOrder<BGRAOrder>(dst, size, ptr);
}

// utils

void readFloat(tcu::Vec4 &dst, const VertexAttribType type, const int size, const void *ptr)
{
    switch (type)
    {
    case VERTEXATTRIBTYPE_FLOAT:
        read<float>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_HALF:
        readHalf(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_FIXED:
        readFixed(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_DOUBLE:
        readDouble(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UNORM8:
        readUnorm<uint8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UNORM16:
        readUnorm<uint16_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UNORM32:
        readUnorm<uint32_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:
        readUnorm2101010Rev(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:
        readSnormClamp<int8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:
        readSnormClamp<int16_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:
        readSnormClamp<int32_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:
        readSnorm2101010RevClamp(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:
        readSnormScale<int8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:
        readSnormScale<int16_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:
        readSnormScale<int32_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:
        readSnorm2101010RevScale(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UINT8:
        read<uint8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UINT16:
        read<uint16_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UINT32:
        read<uint32_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_INT8:
        read<int8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_INT16:
        read<int16_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_INT32:
        read<int32_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:
        readUint2101010Rev(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:
        readInt2101010Rev(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:
        readUnormBGRA<uint8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
        readUnorm2101010RevBGRA(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
        readSnorm2101010RevClampBGRA(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
        readSnorm2101010RevScaleBGRA(dst, size, ptr);
        break;

    case VERTEXATTRIBTYPE_PURE_UINT8:
    case VERTEXATTRIBTYPE_PURE_UINT16:
    case VERTEXATTRIBTYPE_PURE_UINT32:
    case VERTEXATTRIBTYPE_PURE_INT8:
    case VERTEXATTRIBTYPE_PURE_INT16:
    case VERTEXATTRIBTYPE_PURE_INT32:
        DE_FATAL("Invalid read");
        break;

    default:
        DE_ASSERT(false);
    }
}

void readInt(tcu::IVec4 &dst, const VertexAttribType type, const int size, const void *ptr)
{
    switch (type)
    {
    case VERTEXATTRIBTYPE_PURE_INT8:
        read<int8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_PURE_INT16:
        read<int16_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_PURE_INT32:
        read<int32_t>(dst, size, ptr);
        break;

    case VERTEXATTRIBTYPE_FLOAT:
    case VERTEXATTRIBTYPE_HALF:
    case VERTEXATTRIBTYPE_FIXED:
    case VERTEXATTRIBTYPE_DOUBLE:
    case VERTEXATTRIBTYPE_NONPURE_UNORM8:
    case VERTEXATTRIBTYPE_NONPURE_UNORM16:
    case VERTEXATTRIBTYPE_NONPURE_UNORM32:
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_UINT8:
    case VERTEXATTRIBTYPE_NONPURE_UINT16:
    case VERTEXATTRIBTYPE_NONPURE_UINT32:
    case VERTEXATTRIBTYPE_NONPURE_INT8:
    case VERTEXATTRIBTYPE_NONPURE_INT16:
    case VERTEXATTRIBTYPE_NONPURE_INT32:
    case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:
    case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:
    case VERTEXATTRIBTYPE_PURE_UINT8:
    case VERTEXATTRIBTYPE_PURE_UINT16:
    case VERTEXATTRIBTYPE_PURE_UINT32:
    case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
        DE_FATAL("Invalid read");
        break;

    default:
        DE_ASSERT(false);
    }
}

void readUint(tcu::UVec4 &dst, const VertexAttribType type, const int size, const void *ptr)
{
    switch (type)
    {
    case VERTEXATTRIBTYPE_PURE_UINT8:
        read<uint8_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_PURE_UINT16:
        read<uint16_t>(dst, size, ptr);
        break;
    case VERTEXATTRIBTYPE_PURE_UINT32:
        read<uint32_t>(dst, size, ptr);
        break;

    case VERTEXATTRIBTYPE_FLOAT:
    case VERTEXATTRIBTYPE_HALF:
    case VERTEXATTRIBTYPE_FIXED:
    case VERTEXATTRIBTYPE_DOUBLE:
    case VERTEXATTRIBTYPE_NONPURE_UNORM8:
    case VERTEXATTRIBTYPE_NONPURE_UNORM16:
    case VERTEXATTRIBTYPE_NONPURE_UNORM32:
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:
    case VERTEXATTRIBTYPE_NONPURE_UINT8:
    case VERTEXATTRIBTYPE_NONPURE_UINT16:
    case VERTEXATTRIBTYPE_NONPURE_UINT32:
    case VERTEXATTRIBTYPE_NONPURE_INT8:
    case VERTEXATTRIBTYPE_NONPURE_INT16:
    case VERTEXATTRIBTYPE_NONPURE_INT32:
    case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:
    case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:
    case VERTEXATTRIBTYPE_PURE_INT8:
    case VERTEXATTRIBTYPE_PURE_INT16:
    case VERTEXATTRIBTYPE_PURE_INT32:
    case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
        DE_FATAL("Invalid read");
        break;

    default:
        DE_ASSERT(false);
    }
}

int getComponentSize(const VertexAttribType type)
{
    switch (type)
    {
    case VERTEXATTRIBTYPE_FLOAT:
        return 4;
    case VERTEXATTRIBTYPE_HALF:
        return 2;
    case VERTEXATTRIBTYPE_FIXED:
        return 4;
    case VERTEXATTRIBTYPE_DOUBLE:
        return (int)sizeof(double);
    case VERTEXATTRIBTYPE_NONPURE_UNORM8:
        return 1;
    case VERTEXATTRIBTYPE_NONPURE_UNORM16:
        return 2;
    case VERTEXATTRIBTYPE_NONPURE_UNORM32:
        return 4;
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:
        return (int)sizeof(uint32_t) / 4;
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:
        return 1;
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:
        return 2;
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:
        return 4;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:
        return (int)sizeof(uint32_t) / 4;
    case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:
        return 1;
    case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:
        return 2;
    case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:
        return 4;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:
        return (int)sizeof(uint32_t) / 4;
    case VERTEXATTRIBTYPE_NONPURE_UINT8:
        return 1;
    case VERTEXATTRIBTYPE_NONPURE_UINT16:
        return 2;
    case VERTEXATTRIBTYPE_NONPURE_UINT32:
        return 4;
    case VERTEXATTRIBTYPE_NONPURE_INT8:
        return 1;
    case VERTEXATTRIBTYPE_NONPURE_INT16:
        return 2;
    case VERTEXATTRIBTYPE_NONPURE_INT32:
        return 4;
    case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:
        return (int)sizeof(uint32_t) / 4;
    case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:
        return (int)sizeof(uint32_t) / 4;
    case VERTEXATTRIBTYPE_PURE_UINT8:
        return 1;
    case VERTEXATTRIBTYPE_PURE_UINT16:
        return 2;
    case VERTEXATTRIBTYPE_PURE_UINT32:
        return 4;
    case VERTEXATTRIBTYPE_PURE_INT8:
        return 1;
    case VERTEXATTRIBTYPE_PURE_INT16:
        return 2;
    case VERTEXATTRIBTYPE_PURE_INT32:
        return 4;
    case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:
        return 1;
    case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
        return (int)sizeof(uint32_t) / 4;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
        return (int)sizeof(uint32_t) / 4;
    case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
        return (int)sizeof(uint32_t) / 4;
    default:
        DE_ASSERT(false);
        return 0;
    }
}

} // namespace

bool isValidVertexAttrib(const VertexAttrib &vertexAttrib)
{
    // Trivial range checks.
    if (!de::inBounds<int>(vertexAttrib.type, 0, VERTEXATTRIBTYPE_LAST) || !de::inRange(vertexAttrib.size, 0, 4) ||
        vertexAttrib.instanceDivisor < 0)
        return false;

    // Generic attributes
    if (!vertexAttrib.pointer && vertexAttrib.type != VERTEXATTRIBTYPE_DONT_CARE)
        return false;

    // Packed formats
    if ((vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV ||
         vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV ||
         vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV ||
         vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP ||
         vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE ||
         vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA ||
         vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA ||
         vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA) &&
        vertexAttrib.size != 4)
        return false;

    return true;
}

void readVertexAttrib(tcu::Vec4 &dst, const VertexAttrib &vertexAttrib, const int instanceNdx, const int vertexNdx,
                      const int baseInstanceNdx)
{
    DE_ASSERT(isValidVertexAttrib(vertexAttrib));

    if (vertexAttrib.pointer)
    {
        const int elementNdx = (vertexAttrib.instanceDivisor != 0) ?
                                   baseInstanceNdx + (instanceNdx / vertexAttrib.instanceDivisor) :
                                   vertexNdx;
        const int compSize   = getComponentSize(vertexAttrib.type);
        const int stride     = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size * compSize);
        const int byteOffset = elementNdx * stride;

        dst = tcu::Vec4(0, 0, 0, 1); // defaults
        readFloat(dst, vertexAttrib.type, vertexAttrib.size, (const uint8_t *)vertexAttrib.pointer + byteOffset);
    }
    else
    {
        dst = vertexAttrib.generic.get<float>();
    }
}

void readVertexAttrib(tcu::IVec4 &dst, const VertexAttrib &vertexAttrib, const int instanceNdx, const int vertexNdx,
                      const int baseInstanceNdx)
{
    DE_ASSERT(isValidVertexAttrib(vertexAttrib));

    if (vertexAttrib.pointer)
    {
        const int elementNdx = (vertexAttrib.instanceDivisor != 0) ?
                                   baseInstanceNdx + (instanceNdx / vertexAttrib.instanceDivisor) :
                                   vertexNdx;
        const int compSize   = getComponentSize(vertexAttrib.type);
        const int stride     = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size * compSize);
        const int byteOffset = elementNdx * stride;

        dst = tcu::IVec4(0, 0, 0, 1); // defaults
        readInt(dst, vertexAttrib.type, vertexAttrib.size, (const uint8_t *)vertexAttrib.pointer + byteOffset);
    }
    else
    {
        dst = vertexAttrib.generic.get<int32_t>();
    }
}

void readVertexAttrib(tcu::UVec4 &dst, const VertexAttrib &vertexAttrib, const int instanceNdx, const int vertexNdx,
                      const int baseInstanceNdx)
{
    DE_ASSERT(isValidVertexAttrib(vertexAttrib));

    if (vertexAttrib.pointer)
    {
        const int elementNdx = (vertexAttrib.instanceDivisor != 0) ?
                                   baseInstanceNdx + (instanceNdx / vertexAttrib.instanceDivisor) :
                                   vertexNdx;
        const int compSize   = getComponentSize(vertexAttrib.type);
        const int stride     = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size * compSize);
        const int byteOffset = elementNdx * stride;

        dst = tcu::UVec4(0, 0, 0, 1); // defaults
        readUint(dst, vertexAttrib.type, vertexAttrib.size, (const uint8_t *)vertexAttrib.pointer + byteOffset);
    }
    else
    {
        dst = vertexAttrib.generic.get<uint32_t>();
    }
}

} // namespace rr