framework/referencerenderer/rrVertexAttrib.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program Reference Renderer
   3  * -----------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Vertex attribute fetch.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "rrVertexAttrib.hpp"
  25 #include "tcuFloat.hpp"
  26 #include "deInt32.h"
  27 #include "deMemory.h"
  28
  29 namespace rr
  30 {
  31
  32 namespace
  33 {
  34
  35 struct NormalOrder
  36 {
  37         enum
  38         {
  39                 T0 = 0,
  40                 T1 = 1,
  41                 T2 = 2,
  42                 T3 = 3,
  43         };
  44 };
  45
  46 struct BGRAOrder
  47 {
  48         enum
  49         {
  50                 T0 = 2,
  51                 T1 = 1,
  52                 T2 = 0,
  53                 T3 = 3,
  54         };
  55 };
  56
  57 // readers
  58
  59 template<typename SrcScalarType, typename DstScalarType, typename Order>
  60 inline void readOrder (typename tcu::Vector<DstScalarType, 4>& dst, const int size, const void* ptr)
  61 {
  62         SrcScalarType aligned[4];
  63         deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));
  64
  65                                    dst[Order::T0] = DstScalarType(aligned[0]);
  66         if (size >= 2) dst[Order::T1] = DstScalarType(aligned[1]);
  67         if (size >= 3) dst[Order::T2] = DstScalarType(aligned[2]);
  68         if (size >= 4) dst[Order::T3] = DstScalarType(aligned[3]);
  69 }
  70
  71 template<typename SrcScalarType, typename Order>
  72 inline void readUnormOrder (tcu::Vec4& dst, const int size, const void* ptr)
  73 {
  74         const deUint32 range = (deUint32)((1ull << (sizeof(SrcScalarType)*8))-1);
  75
  76         SrcScalarType aligned[4];
  77         deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));
  78
  79                                    dst[Order::T0] = float(aligned[0]) / float(range);
  80         if (size >= 2) dst[Order::T1] = float(aligned[1]) / float(range);
  81         if (size >= 3) dst[Order::T2] = float(aligned[2]) / float(range);
  82         if (size >= 4) dst[Order::T3] = float(aligned[3]) / float(range);
  83 }
  84
  85 template<typename SrcScalarType>
  86 inline void readSnormClamp (tcu::Vec4& dst, const int size, const void* ptr)
  87 {
  88         // Clamped formats, GLES3-style conversion: max{c / (2^(b-1) - 1), -1 }
  89         const deUint32 range = (deUint32)((1ull << (sizeof(SrcScalarType)*8-1))-1);
  90
  91         SrcScalarType aligned[4];
  92         deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));
  93
  94                                    dst[0] = de::max(-1.0f, float(aligned[0]) / float(range));
  95         if (size >= 2) dst[1] = de::max(-1.0f, float(aligned[1]) / float(range));
  96         if (size >= 3) dst[2] = de::max(-1.0f, float(aligned[2]) / float(range));
  97         if (size >= 4) dst[3] = de::max(-1.0f, float(aligned[3]) / float(range));
  98 }
  99
 100 template<typename SrcScalarType>
 101 inline void readSnormScale (tcu::Vec4& dst, const int size, const void* ptr)
 102 {
 103         // Scaled formats, GLES2-style conversion: (2c + 1) / (2^b - 1)
 104         const deUint32 range = (deUint32)((1ull << (sizeof(SrcScalarType)*8))-1);
 105
 106         SrcScalarType aligned[4];
 107         deMemcpy(aligned, ptr, size * sizeof(SrcScalarType));
 108
 109                                    dst[0] = (float(aligned[0]) * 2.0f + 1.0f) / float(range);
 110         if (size >= 2) dst[1] = (float(aligned[1]) * 2.0f + 1.0f) / float(range);
 111         if (size >= 3) dst[2] = (float(aligned[2]) * 2.0f + 1.0f) / float(range);
 112         if (size >= 4) dst[3] = (float(aligned[3]) * 2.0f + 1.0f) / float(range);
 113 }
 114
 115 inline void readHalf (tcu::Vec4& dst, const int size, const void* ptr)
 116 {
 117         deUint16 aligned[4];
 118         deMemcpy(aligned, ptr, size * sizeof(deUint16));
 119
 120                                    dst[0] = tcu::Float16(aligned[0]).asFloat();
 121         if (size >= 2) dst[1] = tcu::Float16(aligned[1]).asFloat();
 122         if (size >= 3) dst[2] = tcu::Float16(aligned[2]).asFloat();
 123         if (size >= 4) dst[3] = tcu::Float16(aligned[3]).asFloat();
 124 }
 125
 126 inline void readFixed (tcu::Vec4& dst, const int size, const void* ptr)
 127 {
 128         deInt32 aligned[4];
 129         deMemcpy(aligned, ptr, size * sizeof(deInt32));
 130
 131                                    dst[0] = float(aligned[0]) / float(1 << 16);
 132         if (size >= 2) dst[1] = float(aligned[1]) / float(1 << 16);
 133         if (size >= 3) dst[2] = float(aligned[2]) / float(1 << 16);
 134         if (size >= 4) dst[3] = float(aligned[3]) / float(1 << 16);
 135 }
 136
 137 inline void readDouble (tcu::Vec4& dst, const int size, const void* ptr)
 138 {
 139         double aligned[4];
 140         deMemcpy(aligned, ptr, size * sizeof(double));
 141
 142                                    dst[0] = float(aligned[0]);
 143         if (size >= 2) dst[1] = float(aligned[1]);
 144         if (size >= 3) dst[2] = float(aligned[2]);
 145         if (size >= 4) dst[3] = float(aligned[3]);
 146 }
 147
 148 template <int integerLen>
 149 inline deInt32 extendSign (deUint32 integer)
 150 {
 151         return deUint32(0 - deInt32((integer & (1 << (integerLen - 1))) << 1)) | integer;
 152 }
 153
 154 template<typename DstScalarType>
 155 inline void readUint2101010Rev (typename tcu::Vector<DstScalarType, 4>& dst, const int size, const void* ptr)
 156 {
 157         deUint32 aligned;
 158         deMemcpy(&aligned, ptr, sizeof(deUint32));
 159
 160                                    dst[0] = DstScalarType((aligned >>  0) & ((1 << 10) - 1));
 161         if (size >= 2) dst[1] = DstScalarType((aligned >> 10) & ((1 << 10) - 1));
 162         if (size >= 3) dst[2] = DstScalarType((aligned >> 20) & ((1 << 10) - 1));
 163         if (size >= 4) dst[3] = DstScalarType((aligned >> 30) & ((1 <<  2) - 1));
 164 }
 165
 166 template<typename DstScalarType>
 167 inline void readInt2101010Rev (typename tcu::Vector<DstScalarType, 4>& dst, const int size, const void* ptr)
 168 {
 169         deUint32 aligned;
 170         deMemcpy(&aligned, ptr, sizeof(deUint32));
 171
 172                                    dst[0] = (DstScalarType)extendSign<10>((aligned >>  0) & ((1 << 10) - 1));
 173         if (size >= 2) dst[1] = (DstScalarType)extendSign<10>((aligned >> 10) & ((1 << 10) - 1));
 174         if (size >= 3) dst[2] = (DstScalarType)extendSign<10>((aligned >> 20) & ((1 << 10) - 1));
 175         if (size >= 4) dst[3] = (DstScalarType)extendSign< 2>((aligned >> 30) & ((1 <<  2) - 1));
 176 }
 177
 178 template<typename Order>
 179 inline void readUnorm2101010RevOrder (tcu::Vec4& dst, const int size, const void* ptr)
 180 {
 181         const deUint32 range10 = (deUint32)((1ull << 10)-1);
 182         const deUint32 range2 = (deUint32)((1ull <<  2)-1);
 183
 184         deUint32 aligned;
 185         deMemcpy(&aligned, ptr, sizeof(deUint32));
 186
 187                                    dst[Order::T0] = float((aligned >>  0) & ((1 << 10) - 1)) / float(range10);
 188         if (size >= 2) dst[Order::T1] = float((aligned >> 10) & ((1 << 10) - 1)) / float(range10);
 189         if (size >= 3) dst[Order::T2] = float((aligned >> 20) & ((1 << 10) - 1)) / float(range10);
 190         if (size >= 4) dst[Order::T3] = float((aligned >> 30) & ((1 <<  2) - 1)) / float(range2);
 191 }
 192
 193 template<typename Order>
 194 inline void readSnorm2101010RevClampOrder (tcu::Vec4& dst, const int size, const void* ptr)
 195 {
 196         // Clamped formats, GLES3-style conversion: max{c / (2^(b-1) - 1), -1 }
 197         const deUint32 range10 = (deUint32)((1ull << (10-1))-1);
 198         const deUint32 range2  = (deUint32)((1ull << ( 2-1))-1);
 199
 200         deUint32 aligned;
 201         deMemcpy(&aligned, ptr, sizeof(deUint32));
 202
 203                                    dst[Order::T0] = de::max(-1.0f, float(extendSign<10>((aligned >>  0) & ((1 << 10) - 1))) / float(range10));
 204         if (size >= 2) dst[Order::T1] = de::max(-1.0f, float(extendSign<10>((aligned >> 10) & ((1 << 10) - 1))) / float(range10));
 205         if (size >= 3) dst[Order::T2] = de::max(-1.0f, float(extendSign<10>((aligned >> 20) & ((1 << 10) - 1))) / float(range10));
 206         if (size >= 4) dst[Order::T3] = de::max(-1.0f, float(extendSign< 2>((aligned >> 30) & ((1 <<  2) - 1))) / float(range2));
 207 }
 208
 209 template<typename Order>
 210 inline void readSnorm2101010RevScaleOrder (tcu::Vec4& dst, const int size, const void* ptr)
 211 {
 212         // Scaled formats, GLES2-style conversion: (2c + 1) / (2^b - 1)
 213         const deUint32 range10 = (deUint32)((1ull << 10)-1);
 214         const deUint32 range2  = (deUint32)((1ull <<  2)-1);
 215
 216         deUint32 aligned;
 217         deMemcpy(&aligned, ptr, sizeof(deUint32));
 218
 219                                    dst[Order::T0] = (float(extendSign<10>((aligned >>  0) & ((1 << 10) - 1))) * 2.0f + 1.0f) / float(range10);
 220         if (size >= 2) dst[Order::T1] = (float(extendSign<10>((aligned >> 10) & ((1 << 10) - 1))) * 2.0f + 1.0f) / float(range10);
 221         if (size >= 3) dst[Order::T2] = (float(extendSign<10>((aligned >> 20) & ((1 << 10) - 1))) * 2.0f + 1.0f) / float(range10);
 222         if (size >= 4) dst[Order::T3] = (float(extendSign< 2>((aligned >> 30) & ((1 <<  2) - 1))) * 2.0f + 1.0f) / float(range2);
 223 }
 224
 225 // ordered readers
 226
 227 template<typename SrcScalarType, typename DstScalarType>
 228 inline void read (typename tcu::Vector<DstScalarType, 4>& dst, const int size, const void* ptr)
 229 {
 230         readOrder<SrcScalarType, DstScalarType, NormalOrder>(dst, size, ptr);
 231 }
 232
 233 template<typename SrcScalarType>
 234 inline void readUnorm (tcu::Vec4& dst, const int size, const void* ptr)
 235 {
 236         readUnormOrder<SrcScalarType, NormalOrder>(dst, size, ptr);
 237 }
 238
 239 template<typename SrcScalarType>
 240 inline void readUnormBGRA (tcu::Vec4& dst, const int size, const void* ptr)
 241 {
 242         readUnormOrder<SrcScalarType, BGRAOrder>(dst, size, ptr);
 243 }
 244
 245 inline void readUnorm2101010Rev (tcu::Vec4& dst, const int size, const void* ptr)
 246 {
 247         readUnorm2101010RevOrder<NormalOrder>(dst, size, ptr);
 248 }
 249
 250 inline void readUnorm2101010RevBGRA (tcu::Vec4& dst, const int size, const void* ptr)
 251 {
 252         readUnorm2101010RevOrder<BGRAOrder>(dst, size, ptr);
 253 }
 254
 255 inline void readSnorm2101010RevClamp (tcu::Vec4& dst, const int size, const void* ptr)
 256 {
 257         readSnorm2101010RevClampOrder<NormalOrder>(dst, size, ptr);
 258 }
 259
 260 inline void readSnorm2101010RevClampBGRA (tcu::Vec4& dst, const int size, const void* ptr)
 261 {
 262         readSnorm2101010RevClampOrder<BGRAOrder>(dst, size, ptr);
 263 }
 264
 265 inline void readSnorm2101010RevScale (tcu::Vec4& dst, const int size, const void* ptr)
 266 {
 267         readSnorm2101010RevScaleOrder<NormalOrder>(dst, size, ptr);
 268 }
 269
 270 inline void readSnorm2101010RevScaleBGRA (tcu::Vec4& dst, const int size, const void* ptr)
 271 {
 272         readSnorm2101010RevScaleOrder<BGRAOrder>(dst, size, ptr);
 273 }
 274
 275 // utils
 276
 277 void readFloat (tcu::Vec4& dst, const VertexAttribType type, const int size, const void* ptr)
 278 {
 279         switch (type)
 280         {
 281                 case VERTEXATTRIBTYPE_FLOAT:                                                                    read<float>                                     (dst, size, ptr);       break;
 282                 case VERTEXATTRIBTYPE_HALF:                                                                             readHalf                                        (dst, size, ptr);       break;
 283                 case VERTEXATTRIBTYPE_FIXED:                                                                    readFixed                                       (dst, size, ptr);       break;
 284                 case VERTEXATTRIBTYPE_DOUBLE:                                                                   readDouble                                      (dst, size, ptr);       break;
 285                 case VERTEXATTRIBTYPE_NONPURE_UNORM8:                                                   readUnorm<deUint8>                      (dst, size, ptr);       break;
 286                 case VERTEXATTRIBTYPE_NONPURE_UNORM16:                                                  readUnorm<deUint16>                     (dst, size, ptr);       break;
 287                 case VERTEXATTRIBTYPE_NONPURE_UNORM32:                                                  readUnorm<deUint32>                     (dst, size, ptr);       break;
 288                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:                             readUnorm2101010Rev                     (dst, size, ptr);       break;
 289                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:                                             readSnormClamp<deInt8>          (dst, size, ptr);       break;
 290                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:                                    readSnormClamp<deInt16>         (dst, size, ptr);       break;
 291                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:                                    readSnormClamp<deInt32>         (dst, size, ptr);       break;
 292                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:               readSnorm2101010RevClamp        (dst, size, ptr);       break;
 293                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:                                             readSnormScale<deInt8>          (dst, size, ptr);       break;
 294                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:                                    readSnormScale<deInt16>         (dst, size, ptr);       break;
 295                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:                                    readSnormScale<deInt32>         (dst, size, ptr);       break;
 296                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:               readSnorm2101010RevScale        (dst, size, ptr);       break;
 297                 case VERTEXATTRIBTYPE_NONPURE_UINT8:                                                    read<deUint8>                           (dst, size, ptr);       break;
 298                 case VERTEXATTRIBTYPE_NONPURE_UINT16:                                                   read<deUint16>                          (dst, size, ptr);       break;
 299                 case VERTEXATTRIBTYPE_NONPURE_UINT32:                                                   read<deUint32>                          (dst, size, ptr);       break;
 300                 case VERTEXATTRIBTYPE_NONPURE_INT8:                                                             read<deInt8>                            (dst, size, ptr);       break;
 301                 case VERTEXATTRIBTYPE_NONPURE_INT16:                                                    read<deInt16>                           (dst, size, ptr);       break;
 302                 case VERTEXATTRIBTYPE_NONPURE_INT32:                                                    read<deInt32>                           (dst, size, ptr);       break;
 303                 case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:                              readUint2101010Rev                      (dst, size, ptr);       break;
 304                 case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:                               readInt2101010Rev                       (dst, size, ptr);       break;
 305                 case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:                                              readUnormBGRA<deUint8>          (dst, size, ptr);       break;
 306                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:                readUnorm2101010RevBGRA         (dst, size, ptr);       break;
 307                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:  readSnorm2101010RevClampBGRA(dst, size, ptr);   break;
 308                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:  readSnorm2101010RevScaleBGRA(dst, size, ptr);   break;
 309
 310                 case VERTEXATTRIBTYPE_PURE_UINT8:
 311                 case VERTEXATTRIBTYPE_PURE_UINT16:
 312                 case VERTEXATTRIBTYPE_PURE_UINT32:
 313                 case VERTEXATTRIBTYPE_PURE_INT8:
 314                 case VERTEXATTRIBTYPE_PURE_INT16:
 315                 case VERTEXATTRIBTYPE_PURE_INT32:
 316                         DE_FATAL("Invalid read");
 317
 318                 default:
 319                         DE_ASSERT(false);
 320         }
 321 }
 322
 323 void readInt (tcu::IVec4& dst, const VertexAttribType type, const int size, const void* ptr)
 324 {
 325         switch (type)
 326         {
 327                 case VERTEXATTRIBTYPE_PURE_INT8:                                read<deInt8>            (dst, size, ptr);       break;
 328                 case VERTEXATTRIBTYPE_PURE_INT16:                               read<deInt16>           (dst, size, ptr);       break;
 329                 case VERTEXATTRIBTYPE_PURE_INT32:                               read<deInt32>           (dst, size, ptr);       break;
 330
 331                 case VERTEXATTRIBTYPE_FLOAT:
 332                 case VERTEXATTRIBTYPE_HALF:
 333                 case VERTEXATTRIBTYPE_FIXED:
 334                 case VERTEXATTRIBTYPE_DOUBLE:
 335                 case VERTEXATTRIBTYPE_NONPURE_UNORM8:
 336                 case VERTEXATTRIBTYPE_NONPURE_UNORM16:
 337                 case VERTEXATTRIBTYPE_NONPURE_UNORM32:
 338                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:
 339                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:
 340                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:
 341                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:
 342                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:
 343                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:
 344                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:
 345                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:
 346                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:
 347                 case VERTEXATTRIBTYPE_NONPURE_UINT8:
 348                 case VERTEXATTRIBTYPE_NONPURE_UINT16:
 349                 case VERTEXATTRIBTYPE_NONPURE_UINT32:
 350                 case VERTEXATTRIBTYPE_NONPURE_INT8:
 351                 case VERTEXATTRIBTYPE_NONPURE_INT16:
 352                 case VERTEXATTRIBTYPE_NONPURE_INT32:
 353                 case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:
 354                 case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:
 355                 case VERTEXATTRIBTYPE_PURE_UINT8:
 356                 case VERTEXATTRIBTYPE_PURE_UINT16:
 357                 case VERTEXATTRIBTYPE_PURE_UINT32:
 358                 case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:
 359                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
 360                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
 361                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
 362                         DE_FATAL("Invalid read");
 363
 364                 default:
 365                         DE_ASSERT(false);
 366         }
 367 }
 368
 369 void readUint (tcu::UVec4& dst, const VertexAttribType type, const int size, const void* ptr)
 370 {
 371         switch (type)
 372         {
 373                 case VERTEXATTRIBTYPE_PURE_UINT8:                               read<deUint8>           (dst, size, ptr);       break;
 374                 case VERTEXATTRIBTYPE_PURE_UINT16:                              read<deUint16>          (dst, size, ptr);       break;
 375                 case VERTEXATTRIBTYPE_PURE_UINT32:                              read<deUint32>          (dst, size, ptr);       break;
 376
 377                 case VERTEXATTRIBTYPE_FLOAT:
 378                 case VERTEXATTRIBTYPE_HALF:
 379                 case VERTEXATTRIBTYPE_FIXED:
 380                 case VERTEXATTRIBTYPE_DOUBLE:
 381                 case VERTEXATTRIBTYPE_NONPURE_UNORM8:
 382                 case VERTEXATTRIBTYPE_NONPURE_UNORM16:
 383                 case VERTEXATTRIBTYPE_NONPURE_UNORM32:
 384                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:
 385                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:
 386                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:
 387                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:
 388                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:
 389                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:
 390                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:
 391                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:
 392                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:
 393                 case VERTEXATTRIBTYPE_NONPURE_UINT8:
 394                 case VERTEXATTRIBTYPE_NONPURE_UINT16:
 395                 case VERTEXATTRIBTYPE_NONPURE_UINT32:
 396                 case VERTEXATTRIBTYPE_NONPURE_INT8:
 397                 case VERTEXATTRIBTYPE_NONPURE_INT16:
 398                 case VERTEXATTRIBTYPE_NONPURE_INT32:
 399                 case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:
 400                 case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:
 401                 case VERTEXATTRIBTYPE_PURE_INT8:
 402                 case VERTEXATTRIBTYPE_PURE_INT16:
 403                 case VERTEXATTRIBTYPE_PURE_INT32:
 404                 case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:
 405                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:
 406                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:
 407                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:
 408                         DE_FATAL("Invalid read");
 409
 410                 default:
 411                         DE_ASSERT(false);
 412         }
 413 }
 414
 415 int getComponentSize (const VertexAttribType type)
 416 {
 417         switch (type)
 418         {
 419                 case VERTEXATTRIBTYPE_FLOAT:                                                                    return 4;
 420                 case VERTEXATTRIBTYPE_HALF:                                                                             return 2;
 421                 case VERTEXATTRIBTYPE_FIXED:                                                                    return 4;
 422                 case VERTEXATTRIBTYPE_DOUBLE:                                                                   return (int)sizeof(double);
 423                 case VERTEXATTRIBTYPE_NONPURE_UNORM8:                                                   return 1;
 424                 case VERTEXATTRIBTYPE_NONPURE_UNORM16:                                                  return 2;
 425                 case VERTEXATTRIBTYPE_NONPURE_UNORM32:                                                  return 4;
 426                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV:                             return (int)sizeof(deUint32)/4;
 427                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_CLAMP:                                             return 1;
 428                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_CLAMP:                                    return 2;
 429                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_CLAMP:                                    return 4;
 430                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP:               return (int)sizeof(deUint32)/4;
 431                 case VERTEXATTRIBTYPE_NONPURE_SNORM8_SCALE:                                             return 1;
 432                 case VERTEXATTRIBTYPE_NONPURE_SNORM16_SCALE:                                    return 2;
 433                 case VERTEXATTRIBTYPE_NONPURE_SNORM32_SCALE:                                    return 4;
 434                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE:               return (int)sizeof(deUint32)/4;
 435                 case VERTEXATTRIBTYPE_NONPURE_UINT8:                                                    return 1;
 436                 case VERTEXATTRIBTYPE_NONPURE_UINT16:                                                   return 2;
 437                 case VERTEXATTRIBTYPE_NONPURE_UINT32:                                                   return 4;
 438                 case VERTEXATTRIBTYPE_NONPURE_INT8:                                                             return 1;
 439                 case VERTEXATTRIBTYPE_NONPURE_INT16:                                                    return 2;
 440                 case VERTEXATTRIBTYPE_NONPURE_INT32:                                                    return 4;
 441                 case VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV:                              return (int)sizeof(deUint32)/4;
 442                 case VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV:                               return (int)sizeof(deUint32)/4;
 443                 case VERTEXATTRIBTYPE_PURE_UINT8:                                                               return 1;
 444                 case VERTEXATTRIBTYPE_PURE_UINT16:                                                              return 2;
 445                 case VERTEXATTRIBTYPE_PURE_UINT32:                                                              return 4;
 446                 case VERTEXATTRIBTYPE_PURE_INT8:                                                                return 1;
 447                 case VERTEXATTRIBTYPE_PURE_INT16:                                                               return 2;
 448                 case VERTEXATTRIBTYPE_PURE_INT32:                                                               return 4;
 449                 case VERTEXATTRIBTYPE_NONPURE_UNORM8_BGRA:                                              return 1;
 450                 case VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA:                return (int)sizeof(deUint32)/4;
 451                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA:  return (int)sizeof(deUint32)/4;
 452                 case VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA:  return (int)sizeof(deUint32)/4;
 453                 default:
 454                         DE_ASSERT(false);
 455                         return 0;
 456         }
 457 }
 458
 459 } // anonymous
 460
 461 bool isValidVertexAttrib (const VertexAttrib& vertexAttrib)
 462 {
 463         // Trivial range checks.
 464         if (!de::inBounds<int>(vertexAttrib.type, 0, VERTEXATTRIBTYPE_LAST) ||
 465                 !de::inRange(vertexAttrib.size, 0, 4) ||
 466                 vertexAttrib.instanceDivisor < 0)
 467                 return false;
 468
 469         // Generic attributes
 470         if (!vertexAttrib.pointer && vertexAttrib.type != VERTEXATTRIBTYPE_DONT_CARE)
 471                 return false;
 472
 473         // Packed formats
 474         if ((vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_INT_2_10_10_10_REV                           ||
 475                  vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_UINT_2_10_10_10_REV                              ||
 476                  vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV                             ||
 477                  vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP               ||
 478                  vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE               ||
 479                  vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_UNORM_2_10_10_10_REV_BGRA                ||
 480                  vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_CLAMP_BGRA  ||
 481                  vertexAttrib.type == VERTEXATTRIBTYPE_NONPURE_SNORM_2_10_10_10_REV_SCALE_BGRA) &&
 482                 vertexAttrib.size != 4)
 483                 return false;
 484
 485         return true;
 486 }
 487
 488 void readVertexAttrib (tcu::Vec4& dst, const VertexAttrib& vertexAttrib, const int instanceNdx, const int vertexNdx)
 489 {
 490         DE_ASSERT(isValidVertexAttrib(vertexAttrib));
 491
 492         if (vertexAttrib.pointer)
 493         {
 494                 const int       elementNdx              = (vertexAttrib.instanceDivisor != 0) ? (instanceNdx / vertexAttrib.instanceDivisor) : vertexNdx;
 495                 const int       compSize                = getComponentSize(vertexAttrib.type);
 496                 const int       stride                  = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size*compSize);
 497                 const int       byteOffset              = elementNdx*stride;
 498
 499                 dst = tcu::Vec4(0, 0, 0, 1); // defaults
 500                 readFloat(dst, vertexAttrib.type, vertexAttrib.size, (const deUint8*)vertexAttrib.pointer + byteOffset);
 501         }
 502         else
 503         {
 504                 dst = vertexAttrib.generic.get<float>();
 505         }
 506 }
 507
 508 void readVertexAttrib (tcu::IVec4& dst, const VertexAttrib& vertexAttrib, const int instanceNdx, const int vertexNdx)
 509 {
 510         DE_ASSERT(isValidVertexAttrib(vertexAttrib));
 511
 512         if (vertexAttrib.pointer)
 513         {
 514                 const int       elementNdx              = (vertexAttrib.instanceDivisor != 0) ? (instanceNdx / vertexAttrib.instanceDivisor) : vertexNdx;
 515                 const int       compSize                = getComponentSize(vertexAttrib.type);
 516                 const int       stride                  = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size*compSize);
 517                 const int       byteOffset              = elementNdx*stride;
 518
 519                 dst = tcu::IVec4(0, 0, 0, 1); // defaults
 520                 readInt(dst, vertexAttrib.type, vertexAttrib.size, (const deUint8*)vertexAttrib.pointer + byteOffset);
 521         }
 522         else
 523         {
 524                 dst = vertexAttrib.generic.get<deInt32>();
 525         }
 526 }
 527
 528 void readVertexAttrib (tcu::UVec4& dst, const VertexAttrib& vertexAttrib, const int instanceNdx, const int vertexNdx)
 529 {
 530         DE_ASSERT(isValidVertexAttrib(vertexAttrib));
 531
 532         if (vertexAttrib.pointer)
 533         {
 534                 const int       elementNdx              = (vertexAttrib.instanceDivisor != 0) ? (instanceNdx / vertexAttrib.instanceDivisor) : vertexNdx;
 535                 const int       compSize                = getComponentSize(vertexAttrib.type);
 536                 const int       stride                  = (vertexAttrib.stride != 0) ? (vertexAttrib.stride) : (vertexAttrib.size*compSize);
 537                 const int       byteOffset              = elementNdx*stride;
 538
 539                 dst = tcu::UVec4(0, 0, 0, 1); // defaults
 540                 readUint(dst, vertexAttrib.type, vertexAttrib.size, (const deUint8*)vertexAttrib.pointer + byteOffset);
 541         }
 542         else
 543         {
 544                 dst = vertexAttrib.generic.get<deUint32>();
 545         }
 546 }
 547
 548 } // rr