modules/glshared/glsDrawTest.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL (ES) Module
   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 Draw tests
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "glsDrawTest.hpp"
  25
  26 #include "deRandom.h"
  27 #include "deRandom.hpp"
  28 #include "deMath.h"
  29 #include "deStringUtil.hpp"
  30 #include "deFloat16.h"
  31 #include "deUniquePtr.hpp"
  32 #include "deArrayUtil.hpp"
  33
  34 #include "tcuTestLog.hpp"
  35 #include "tcuPixelFormat.hpp"
  36 #include "tcuRGBA.hpp"
  37 #include "tcuSurface.hpp"
  38 #include "tcuVector.hpp"
  39 #include "tcuTestLog.hpp"
  40 #include "tcuRenderTarget.hpp"
  41 #include "tcuStringTemplate.hpp"
  42 #include "tcuImageCompare.hpp"
  43 #include "tcuFloat.hpp"
  44 #include "tcuTextureUtil.hpp"
  45
  46 #include "gluContextInfo.hpp"
  47 #include "gluPixelTransfer.hpp"
  48 #include "gluCallLogWrapper.hpp"
  49
  50 #include "sglrContext.hpp"
  51 #include "sglrReferenceContext.hpp"
  52 #include "sglrGLContext.hpp"
  53
  54 #include "rrGenericVector.hpp"
  55
  56 #include <cstring>
  57 #include <cmath>
  58 #include <vector>
  59 #include <sstream>
  60 #include <limits>
  61
  62 #include "glwDefs.hpp"
  63 #include "glwEnums.hpp"
  64
  65 namespace deqp
  66 {
  67 namespace gls
  68 {
  69 namespace
  70 {
  71
  72 using tcu::TestLog;
  73 using namespace glw; // GL types
  74
  75 const int MAX_RENDER_TARGET_SIZE = 512;
  76
  77 // Utils
  78
  79 static GLenum targetToGL (DrawTestSpec::Target target)
  80 {
  81         static const GLenum targets[] =
  82         {
  83                 GL_ELEMENT_ARRAY_BUFFER,        // TARGET_ELEMENT_ARRAY = 0,
  84                 GL_ARRAY_BUFFER                         // TARGET_ARRAY,
  85         };
  86
  87         return de::getSizedArrayElement<DrawTestSpec::TARGET_LAST>(targets, (int)target);
  88 }
  89
  90 static GLenum usageToGL (DrawTestSpec::Usage usage)
  91 {
  92         static const GLenum usages[] =
  93         {
  94                 GL_DYNAMIC_DRAW,        // USAGE_DYNAMIC_DRAW = 0,
  95                 GL_STATIC_DRAW,         // USAGE_STATIC_DRAW,
  96                 GL_STREAM_DRAW,         // USAGE_STREAM_DRAW,
  97
  98                 GL_STREAM_READ,         // USAGE_STREAM_READ,
  99                 GL_STREAM_COPY,         // USAGE_STREAM_COPY,
 100
 101                 GL_STATIC_READ,         // USAGE_STATIC_READ,
 102                 GL_STATIC_COPY,         // USAGE_STATIC_COPY,
 103
 104                 GL_DYNAMIC_READ,        // USAGE_DYNAMIC_READ,
 105                 GL_DYNAMIC_COPY         // USAGE_DYNAMIC_COPY,
 106         };
 107
 108         return de::getSizedArrayElement<DrawTestSpec::USAGE_LAST>(usages, (int)usage);
 109 }
 110
 111 static GLenum inputTypeToGL (DrawTestSpec::InputType type)
 112 {
 113         static const GLenum types[] =
 114         {
 115                 GL_FLOAT,                               // INPUTTYPE_FLOAT = 0,
 116                 GL_FIXED,                               // INPUTTYPE_FIXED,
 117                 GL_DOUBLE,                              // INPUTTYPE_DOUBLE
 118                 GL_BYTE,                                // INPUTTYPE_BYTE,
 119                 GL_SHORT,                               // INPUTTYPE_SHORT,
 120                 GL_UNSIGNED_BYTE,               // INPUTTYPE_UNSIGNED_BYTE,
 121                 GL_UNSIGNED_SHORT,              // INPUTTYPE_UNSIGNED_SHORT,
 122
 123                 GL_INT,                                 // INPUTTYPE_INT,
 124                 GL_UNSIGNED_INT,                // INPUTTYPE_UNSIGNED_INT,
 125                 GL_HALF_FLOAT,                  // INPUTTYPE_HALF,
 126                 GL_UNSIGNED_INT_2_10_10_10_REV, // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
 127                 GL_INT_2_10_10_10_REV                   // INPUTTYPE_INT_2_10_10_10,
 128         };
 129
 130         return de::getSizedArrayElement<DrawTestSpec::INPUTTYPE_LAST>(types, (int)type);
 131 }
 132
 133 static std::string outputTypeToGLType (DrawTestSpec::OutputType type)
 134 {
 135         static const char* types[] =
 136         {
 137                 "float",                // OUTPUTTYPE_FLOAT = 0,
 138                 "vec2",                 // OUTPUTTYPE_VEC2,
 139                 "vec3",                 // OUTPUTTYPE_VEC3,
 140                 "vec4",                 // OUTPUTTYPE_VEC4,
 141
 142                 "int",                  // OUTPUTTYPE_INT,
 143                 "uint",                 // OUTPUTTYPE_UINT,
 144
 145                 "ivec2",                // OUTPUTTYPE_IVEC2,
 146                 "ivec3",                // OUTPUTTYPE_IVEC3,
 147                 "ivec4",                // OUTPUTTYPE_IVEC4,
 148
 149                 "uvec2",                // OUTPUTTYPE_UVEC2,
 150                 "uvec3",                // OUTPUTTYPE_UVEC3,
 151                 "uvec4",                // OUTPUTTYPE_UVEC4,
 152         };
 153
 154         return de::getSizedArrayElement<DrawTestSpec::OUTPUTTYPE_LAST>(types, (int)type);
 155 }
 156
 157 static GLenum primitiveToGL (DrawTestSpec::Primitive primitive)
 158 {
 159         static const GLenum primitives[] =
 160         {
 161                 GL_POINTS,                                              // PRIMITIVE_POINTS = 0,
 162                 GL_TRIANGLES,                                   // PRIMITIVE_TRIANGLES,
 163                 GL_TRIANGLE_FAN,                                // PRIMITIVE_TRIANGLE_FAN,
 164                 GL_TRIANGLE_STRIP,                              // PRIMITIVE_TRIANGLE_STRIP,
 165                 GL_LINES,                                               // PRIMITIVE_LINES
 166                 GL_LINE_STRIP,                                  // PRIMITIVE_LINE_STRIP
 167                 GL_LINE_LOOP,                                   // PRIMITIVE_LINE_LOOP
 168                 GL_LINES_ADJACENCY,                             // PRIMITIVE_LINES_ADJACENCY
 169                 GL_LINE_STRIP_ADJACENCY,                // PRIMITIVE_LINE_STRIP_ADJACENCY
 170                 GL_TRIANGLES_ADJACENCY,                 // PRIMITIVE_TRIANGLES_ADJACENCY
 171                 GL_TRIANGLE_STRIP_ADJACENCY,    // PRIMITIVE_TRIANGLE_STRIP_ADJACENCY
 172         };
 173
 174         return de::getSizedArrayElement<DrawTestSpec::PRIMITIVE_LAST>(primitives, (int)primitive);
 175 }
 176
 177 static deUint32 indexTypeToGL (DrawTestSpec::IndexType indexType)
 178 {
 179         static const GLenum indexTypes[] =
 180         {
 181                 GL_UNSIGNED_BYTE,       // INDEXTYPE_BYTE = 0,
 182                 GL_UNSIGNED_SHORT,      // INDEXTYPE_SHORT,
 183                 GL_UNSIGNED_INT,        // INDEXTYPE_INT,
 184         };
 185
 186         return de::getSizedArrayElement<DrawTestSpec::INDEXTYPE_LAST>(indexTypes, (int)indexType);
 187 }
 188
 189 static bool inputTypeIsFloatType (DrawTestSpec::InputType type)
 190 {
 191         if (type == DrawTestSpec::INPUTTYPE_FLOAT)
 192                 return true;
 193         if (type == DrawTestSpec::INPUTTYPE_FIXED)
 194                 return true;
 195         if (type == DrawTestSpec::INPUTTYPE_HALF)
 196                 return true;
 197         if (type == DrawTestSpec::INPUTTYPE_DOUBLE)
 198                 return true;
 199         return false;
 200 }
 201
 202 static bool outputTypeIsFloatType (DrawTestSpec::OutputType type)
 203 {
 204         if (type == DrawTestSpec::OUTPUTTYPE_FLOAT
 205                 || type == DrawTestSpec::OUTPUTTYPE_VEC2
 206                 || type == DrawTestSpec::OUTPUTTYPE_VEC3
 207                 || type == DrawTestSpec::OUTPUTTYPE_VEC4)
 208                 return true;
 209
 210         return false;
 211 }
 212
 213 static bool outputTypeIsIntType (DrawTestSpec::OutputType type)
 214 {
 215         if (type == DrawTestSpec::OUTPUTTYPE_INT
 216                 || type == DrawTestSpec::OUTPUTTYPE_IVEC2
 217                 || type == DrawTestSpec::OUTPUTTYPE_IVEC3
 218                 || type == DrawTestSpec::OUTPUTTYPE_IVEC4)
 219                 return true;
 220
 221         return false;
 222 }
 223
 224 static bool outputTypeIsUintType (DrawTestSpec::OutputType type)
 225 {
 226         if (type == DrawTestSpec::OUTPUTTYPE_UINT
 227                 || type == DrawTestSpec::OUTPUTTYPE_UVEC2
 228                 || type == DrawTestSpec::OUTPUTTYPE_UVEC3
 229                 || type == DrawTestSpec::OUTPUTTYPE_UVEC4)
 230                 return true;
 231
 232         return false;
 233 }
 234
 235 static size_t getElementCount (DrawTestSpec::Primitive primitive, size_t primitiveCount)
 236 {
 237         switch (primitive)
 238         {
 239                 case DrawTestSpec::PRIMITIVE_POINTS:                                            return primitiveCount;
 240                 case DrawTestSpec::PRIMITIVE_TRIANGLES:                                         return primitiveCount * 3;
 241                 case DrawTestSpec::PRIMITIVE_TRIANGLE_FAN:                                      return primitiveCount + 2;
 242                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP:                            return primitiveCount + 2;
 243                 case DrawTestSpec::PRIMITIVE_LINES:                                                     return primitiveCount * 2;
 244                 case DrawTestSpec::PRIMITIVE_LINE_STRIP:                                        return primitiveCount + 1;
 245                 case DrawTestSpec::PRIMITIVE_LINE_LOOP:                                         return (primitiveCount==1) ? (2) : (primitiveCount);
 246                 case DrawTestSpec::PRIMITIVE_LINES_ADJACENCY:                           return primitiveCount * 4;
 247                 case DrawTestSpec::PRIMITIVE_LINE_STRIP_ADJACENCY:                      return primitiveCount + 3;
 248                 case DrawTestSpec::PRIMITIVE_TRIANGLES_ADJACENCY:                       return primitiveCount * 6;
 249                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP_ADJACENCY:          return primitiveCount * 2 + 4;
 250                 default:
 251                         DE_ASSERT(false);
 252                         return 0;
 253         }
 254 }
 255
 256 struct MethodInfo
 257 {
 258         bool indexed;
 259         bool instanced;
 260         bool ranged;
 261         bool first;
 262         bool baseVertex;
 263         bool indirect;
 264 };
 265
 266 static MethodInfo getMethodInfo (gls::DrawTestSpec::DrawMethod method)
 267 {
 268         static const MethodInfo infos[] =
 269         {
 270                 //      indexed         instanced       ranged          first           baseVertex      indirect
 271                 {       false,          false,          false,          true,           false,          false   }, //!< DRAWMETHOD_DRAWARRAYS,
 272                 {       false,          true,           false,          true,           false,          false   }, //!< DRAWMETHOD_DRAWARRAYS_INSTANCED,
 273                 {       false,          true,           false,          true,           false,          true    }, //!< DRAWMETHOD_DRAWARRAYS_INDIRECT,
 274                 {       true,           false,          false,          false,          false,          false   }, //!< DRAWMETHOD_DRAWELEMENTS,
 275                 {       true,           false,          true,           false,          false,          false   }, //!< DRAWMETHOD_DRAWELEMENTS_RANGED,
 276                 {       true,           true,           false,          false,          false,          false   }, //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED,
 277                 {       true,           true,           false,          false,          true,           true    }, //!< DRAWMETHOD_DRAWELEMENTS_INDIRECT,
 278                 {       true,           false,          false,          false,          true,           false   }, //!< DRAWMETHOD_DRAWELEMENTS_BASEVERTEX,
 279                 {       true,           true,           false,          false,          true,           false   }, //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED_BASEVERTEX,
 280                 {       true,           false,          true,           false,          true,           false   }, //!< DRAWMETHOD_DRAWELEMENTS_RANGED_BASEVERTEX,
 281         };
 282
 283         return de::getSizedArrayElement<DrawTestSpec::DRAWMETHOD_LAST>(infos, (int)method);
 284 }
 285
 286 template<class T>
 287 inline static void alignmentSafeAssignment (char* dst, T val)
 288 {
 289         std::memcpy(dst, &val, sizeof(T));
 290 }
 291
 292 static bool checkSpecsShaderCompatible (const DrawTestSpec& a, const DrawTestSpec& b)
 293 {
 294         // Only the attributes matter
 295         if (a.attribs.size() != b.attribs.size())
 296                 return false;
 297
 298         for (size_t ndx = 0; ndx < a.attribs.size(); ++ndx)
 299         {
 300                 // Only the output type (== shader input type) matters and the usage in the shader.
 301
 302                 if (a.attribs[ndx].additionalPositionAttribute != b.attribs[ndx].additionalPositionAttribute)
 303                         return false;
 304
 305                 // component counts need not to match
 306                 if (outputTypeIsFloatType(a.attribs[ndx].outputType) && outputTypeIsFloatType(b.attribs[ndx].outputType))
 307                         continue;
 308                 if (outputTypeIsIntType(a.attribs[ndx].outputType) && outputTypeIsIntType(b.attribs[ndx].outputType))
 309                         continue;
 310                 if (outputTypeIsUintType(a.attribs[ndx].outputType) && outputTypeIsUintType(b.attribs[ndx].outputType))
 311                         continue;
 312
 313                 return false;
 314         }
 315
 316         return true;
 317 }
 318
 319 // generate random vectors in a way that does not depend on argument evaluation order
 320
 321 tcu::Vec4 generateRandomVec4 (de::Random& random)
 322 {
 323         tcu::Vec4 retVal;
 324
 325         for (int i = 0; i < 4; ++i)
 326                 retVal[i] = random.getFloat();
 327
 328         return retVal;
 329 }
 330
 331 tcu::IVec4 generateRandomIVec4 (de::Random& random)
 332 {
 333         tcu::IVec4 retVal;
 334
 335         for (int i = 0; i < 4; ++i)
 336                 retVal[i] = random.getUint32();
 337
 338         return retVal;
 339 }
 340
 341 tcu::UVec4 generateRandomUVec4 (de::Random& random)
 342 {
 343         tcu::UVec4 retVal;
 344
 345         for (int i = 0; i < 4; ++i)
 346                 retVal[i] = random.getUint32();
 347
 348         return retVal;
 349 }
 350
 351 // IterationLogSectionEmitter
 352
 353 class IterationLogSectionEmitter
 354 {
 355 public:
 356                                                                 IterationLogSectionEmitter              (tcu::TestLog& log, size_t testIteration, size_t testIterations, const std::string& description, bool enabled);
 357                                                                 ~IterationLogSectionEmitter             (void);
 358 private:
 359                                                                 IterationLogSectionEmitter              (const IterationLogSectionEmitter&); // delete
 360         IterationLogSectionEmitter&     operator=                                               (const IterationLogSectionEmitter&); // delete
 361
 362         tcu::TestLog&                           m_log;
 363         bool                                            m_enabled;
 364 };
 365
 366 IterationLogSectionEmitter::IterationLogSectionEmitter (tcu::TestLog& log, size_t testIteration, size_t testIterations, const std::string& description, bool enabled)
 367         : m_log         (log)
 368         , m_enabled     (enabled)
 369 {
 370         if (m_enabled)
 371         {
 372                 std::ostringstream buf;
 373                 buf << "Iteration " << (testIteration+1) << "/" << testIterations;
 374
 375                 if (!description.empty())
 376                         buf << " - " << description;
 377
 378                 m_log << tcu::TestLog::Section(buf.str(), buf.str());
 379         }
 380 }
 381
 382 IterationLogSectionEmitter::~IterationLogSectionEmitter (void)
 383 {
 384         if (m_enabled)
 385                 m_log << tcu::TestLog::EndSection;
 386 }
 387
 388 // GLValue
 389
 390 class GLValue
 391 {
 392 public:
 393
 394         template<class Type>
 395         class WrappedType
 396         {
 397         public:
 398                 static WrappedType<Type>        create                  (Type value)                                                    { WrappedType<Type> v; v.m_value = value; return v; }
 399                 inline Type                                     getValue                (void) const                                                    { return m_value; }
 400
 401                 inline WrappedType<Type>        operator+               (const WrappedType<Type>& other) const  { return WrappedType<Type>::create((Type)(m_value + other.getValue())); }
 402                 inline WrappedType<Type>        operator*               (const WrappedType<Type>& other) const  { return WrappedType<Type>::create((Type)(m_value * other.getValue())); }
 403                 inline WrappedType<Type>        operator/               (const WrappedType<Type>& other) const  { return WrappedType<Type>::create((Type)(m_value / other.getValue())); }
 404                 inline WrappedType<Type>        operator-               (const WrappedType<Type>& other) const  { return WrappedType<Type>::create((Type)(m_value - other.getValue())); }
 405
 406                 inline WrappedType<Type>&       operator+=              (const WrappedType<Type>& other)                { m_value += other.getValue(); return *this; }
 407                 inline WrappedType<Type>&       operator*=              (const WrappedType<Type>& other)                { m_value *= other.getValue(); return *this; }
 408                 inline WrappedType<Type>&       operator/=              (const WrappedType<Type>& other)                { m_value /= other.getValue(); return *this; }
 409                 inline WrappedType<Type>&       operator-=              (const WrappedType<Type>& other)                { m_value -= other.getValue(); return *this; }
 410
 411                 inline bool                                     operator==              (const WrappedType<Type>& other) const  { return m_value == other.m_value; }
 412                 inline bool                                     operator!=              (const WrappedType<Type>& other) const  { return m_value != other.m_value; }
 413                 inline bool                                     operator<               (const WrappedType<Type>& other) const  { return m_value < other.m_value; }
 414                 inline bool                                     operator>               (const WrappedType<Type>& other) const  { return m_value > other.m_value; }
 415                 inline bool                                     operator<=              (const WrappedType<Type>& other) const  { return m_value <= other.m_value; }
 416                 inline bool                                     operator>=              (const WrappedType<Type>& other) const  { return m_value >= other.m_value; }
 417
 418                 inline                                          operator Type   (void) const                                                    { return m_value; }
 419                 template<class T>
 420                 inline T                                        to                              (void) const                                                    { return (T)m_value; }
 421         private:
 422                 Type    m_value;
 423         };
 424
 425         typedef WrappedType<deInt16>    Short;
 426         typedef WrappedType<deUint16>   Ushort;
 427
 428         typedef WrappedType<deInt8>             Byte;
 429         typedef WrappedType<deUint8>    Ubyte;
 430
 431         typedef WrappedType<float>              Float;
 432         typedef WrappedType<double>             Double;
 433
 434         typedef WrappedType<deInt32>    Int;
 435         typedef WrappedType<deUint32>   Uint;
 436
 437         class Half
 438         {
 439         public:
 440                 static Half                     create                  (float value)                           { Half h; h.m_value = floatToHalf(value); return h; }
 441                 inline deFloat16        getValue                (void) const                            { return m_value; }
 442
 443                 inline Half                     operator+               (const Half& other) const       { return create(halfToFloat(m_value) + halfToFloat(other.getValue())); }
 444                 inline Half                     operator*               (const Half& other) const       { return create(halfToFloat(m_value) * halfToFloat(other.getValue())); }
 445                 inline Half                     operator/               (const Half& other) const       { return create(halfToFloat(m_value) / halfToFloat(other.getValue())); }
 446                 inline Half                     operator-               (const Half& other) const       { return create(halfToFloat(m_value) - halfToFloat(other.getValue())); }
 447
 448                 inline Half&            operator+=              (const Half& other)                     { m_value = floatToHalf(halfToFloat(other.getValue()) + halfToFloat(m_value)); return *this; }
 449                 inline Half&            operator*=              (const Half& other)                     { m_value = floatToHalf(halfToFloat(other.getValue()) * halfToFloat(m_value)); return *this; }
 450                 inline Half&            operator/=              (const Half& other)                     { m_value = floatToHalf(halfToFloat(other.getValue()) / halfToFloat(m_value)); return *this; }
 451                 inline Half&            operator-=              (const Half& other)                     { m_value = floatToHalf(halfToFloat(other.getValue()) - halfToFloat(m_value)); return *this; }
 452
 453                 inline bool                     operator==              (const Half& other) const       { return m_value == other.m_value; }
 454                 inline bool                     operator!=              (const Half& other) const       { return m_value != other.m_value; }
 455                 inline bool                     operator<               (const Half& other) const       { return halfToFloat(m_value) < halfToFloat(other.m_value); }
 456                 inline bool                     operator>               (const Half& other) const       { return halfToFloat(m_value) > halfToFloat(other.m_value); }
 457                 inline bool                     operator<=              (const Half& other) const       { return halfToFloat(m_value) <= halfToFloat(other.m_value); }
 458                 inline bool                     operator>=              (const Half& other) const       { return halfToFloat(m_value) >= halfToFloat(other.m_value); }
 459
 460                 template<class T>
 461                 inline T                        to                              (void) const                            { return (T)halfToFloat(m_value); }
 462
 463                 inline static deFloat16 floatToHalf             (float f);
 464                 inline static float             halfToFloat             (deFloat16 h);
 465         private:
 466                 deFloat16 m_value;
 467         };
 468
 469         class Fixed
 470         {
 471         public:
 472                 static Fixed            create                  (deInt32 value)                         { Fixed v; v.m_value = value; return v; }
 473                 inline deInt32          getValue                (void) const                            { return m_value; }
 474
 475                 inline Fixed            operator+               (const Fixed& other) const      { return create(m_value + other.getValue()); }
 476                 inline Fixed            operator*               (const Fixed& other) const      { return create(m_value * other.getValue()); }
 477                 inline Fixed            operator/               (const Fixed& other) const      { return create(m_value / other.getValue()); }
 478                 inline Fixed            operator-               (const Fixed& other) const      { return create(m_value - other.getValue()); }
 479
 480                 inline Fixed&           operator+=              (const Fixed& other)            { m_value += other.getValue(); return *this; }
 481                 inline Fixed&           operator*=              (const Fixed& other)            { m_value *= other.getValue(); return *this; }
 482                 inline Fixed&           operator/=              (const Fixed& other)            { m_value /= other.getValue(); return *this; }
 483                 inline Fixed&           operator-=              (const Fixed& other)            { m_value -= other.getValue(); return *this; }
 484
 485                 inline bool                     operator==              (const Fixed& other) const      { return m_value == other.m_value; }
 486                 inline bool                     operator!=              (const Fixed& other) const      { return m_value != other.m_value; }
 487                 inline bool                     operator<               (const Fixed& other) const      { return m_value < other.m_value; }
 488                 inline bool                     operator>               (const Fixed& other) const      { return m_value > other.m_value; }
 489                 inline bool                     operator<=              (const Fixed& other) const      { return m_value <= other.m_value; }
 490                 inline bool                     operator>=              (const Fixed& other) const      { return m_value >= other.m_value; }
 491
 492                 inline                          operator deInt32 (void) const                           { return m_value; }
 493                 template<class T>
 494                 inline T                        to                              (void) const                            { return (T)m_value; }
 495         private:
 496                 deInt32                         m_value;
 497         };
 498
 499         // \todo [mika] This is pretty messy
 500                                                 GLValue                 (void)                  : type(DrawTestSpec::INPUTTYPE_LAST) {}
 501         explicit                        GLValue                 (Float value)   : type(DrawTestSpec::INPUTTYPE_FLOAT),                          fl(value)       {}
 502         explicit                        GLValue                 (Fixed value)   : type(DrawTestSpec::INPUTTYPE_FIXED),                          fi(value)       {}
 503         explicit                        GLValue                 (Byte value)    : type(DrawTestSpec::INPUTTYPE_BYTE),                           b(value)        {}
 504         explicit                        GLValue                 (Ubyte value)   : type(DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE),          ub(value)       {}
 505         explicit                        GLValue                 (Short value)   : type(DrawTestSpec::INPUTTYPE_SHORT),                          s(value)        {}
 506         explicit                        GLValue                 (Ushort value)  : type(DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT),         us(value)       {}
 507         explicit                        GLValue                 (Int value)             : type(DrawTestSpec::INPUTTYPE_INT),                            i(value)        {}
 508         explicit                        GLValue                 (Uint value)    : type(DrawTestSpec::INPUTTYPE_UNSIGNED_INT),           ui(value)       {}
 509         explicit                        GLValue                 (Half value)    : type(DrawTestSpec::INPUTTYPE_HALF),                           h(value)        {}
 510         explicit                        GLValue                 (Double value)  : type(DrawTestSpec::INPUTTYPE_DOUBLE),                         d(value)        {}
 511
 512         float                           toFloat                 (void) const;
 513
 514         static GLValue          getMaxValue             (DrawTestSpec::InputType type);
 515         static GLValue          getMinValue             (DrawTestSpec::InputType type);
 516
 517         DrawTestSpec::InputType type;
 518
 519         union
 520         {
 521                 Float           fl;
 522                 Fixed           fi;
 523                 Double          d;
 524                 Byte            b;
 525                 Ubyte           ub;
 526                 Short           s;
 527                 Ushort          us;
 528                 Int                     i;
 529                 Uint            ui;
 530                 Half            h;
 531         };
 532 };
 533
 534 inline deFloat16 GLValue::Half::floatToHalf (float f)
 535 {
 536         // No denorm support.
 537         tcu::Float<deUint16, 5, 10, 15, tcu::FLOAT_HAS_SIGN> v(f);
 538         DE_ASSERT(!v.isNaN() && !v.isInf());
 539         return v.bits();
 540 }
 541
 542 inline float GLValue::Half::halfToFloat (deFloat16 h)
 543 {
 544         return tcu::Float16((deUint16)h).asFloat();
 545 }
 546
 547 float GLValue::toFloat (void) const
 548 {
 549         switch (type)
 550         {
 551                 case DrawTestSpec::INPUTTYPE_FLOAT:
 552                         return fl.getValue();
 553                         break;
 554
 555                 case DrawTestSpec::INPUTTYPE_BYTE:
 556                         return b.getValue();
 557                         break;
 558
 559                 case DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE:
 560                         return ub.getValue();
 561                         break;
 562
 563                 case DrawTestSpec::INPUTTYPE_SHORT:
 564                         return s.getValue();
 565                         break;
 566
 567                 case DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT:
 568                         return us.getValue();
 569                         break;
 570
 571                 case DrawTestSpec::INPUTTYPE_FIXED:
 572                 {
 573                         int maxValue = 65536;
 574                         return (float)(double(2 * fi.getValue() + 1) / (maxValue - 1));
 575
 576                         break;
 577                 }
 578
 579                 case DrawTestSpec::INPUTTYPE_UNSIGNED_INT:
 580                         return (float)ui.getValue();
 581                         break;
 582
 583                 case DrawTestSpec::INPUTTYPE_INT:
 584                         return (float)i.getValue();
 585                         break;
 586
 587                 case DrawTestSpec::INPUTTYPE_HALF:
 588                         return h.to<float>();
 589                         break;
 590
 591                 case DrawTestSpec::INPUTTYPE_DOUBLE:
 592                         return d.to<float>();
 593                         break;
 594
 595                 default:
 596                         DE_ASSERT(false);
 597                         return 0.0f;
 598                         break;
 599         };
 600 }
 601
 602 GLValue GLValue::getMaxValue (DrawTestSpec::InputType type)
 603 {
 604         GLValue rangesHi[(int)DrawTestSpec::INPUTTYPE_LAST];
 605
 606         rangesHi[(int)DrawTestSpec::INPUTTYPE_FLOAT]                    = GLValue(Float::create(127.0f));
 607         rangesHi[(int)DrawTestSpec::INPUTTYPE_DOUBLE]                   = GLValue(Double::create(127.0f));
 608         rangesHi[(int)DrawTestSpec::INPUTTYPE_BYTE]                             = GLValue(Byte::create(127));
 609         rangesHi[(int)DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE]    = GLValue(Ubyte::create(255));
 610         rangesHi[(int)DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT]   = GLValue(Ushort::create(65530));
 611         rangesHi[(int)DrawTestSpec::INPUTTYPE_SHORT]                    = GLValue(Short::create(32760));
 612         rangesHi[(int)DrawTestSpec::INPUTTYPE_FIXED]                    = GLValue(Fixed::create(32760));
 613         rangesHi[(int)DrawTestSpec::INPUTTYPE_INT]                              = GLValue(Int::create(2147483647));
 614         rangesHi[(int)DrawTestSpec::INPUTTYPE_UNSIGNED_INT]             = GLValue(Uint::create(4294967295u));
 615         rangesHi[(int)DrawTestSpec::INPUTTYPE_HALF]                             = GLValue(Half::create(256.0f));
 616
 617         return rangesHi[(int)type];
 618 }
 619
 620 GLValue GLValue::getMinValue (DrawTestSpec::InputType type)
 621 {
 622         GLValue rangesLo[(int)DrawTestSpec::INPUTTYPE_LAST];
 623
 624         rangesLo[(int)DrawTestSpec::INPUTTYPE_FLOAT]                    = GLValue(Float::create(-127.0f));
 625         rangesLo[(int)DrawTestSpec::INPUTTYPE_DOUBLE]                   = GLValue(Double::create(-127.0f));
 626         rangesLo[(int)DrawTestSpec::INPUTTYPE_BYTE]                             = GLValue(Byte::create(-127));
 627         rangesLo[(int)DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE]    = GLValue(Ubyte::create(0));
 628         rangesLo[(int)DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT]   = GLValue(Ushort::create(0));
 629         rangesLo[(int)DrawTestSpec::INPUTTYPE_SHORT]                    = GLValue(Short::create(-32760));
 630         rangesLo[(int)DrawTestSpec::INPUTTYPE_FIXED]                    = GLValue(Fixed::create(-32760));
 631         rangesLo[(int)DrawTestSpec::INPUTTYPE_INT]                              = GLValue(Int::create(-2147483647));
 632         rangesLo[(int)DrawTestSpec::INPUTTYPE_UNSIGNED_INT]             = GLValue(Uint::create(0));
 633         rangesLo[(int)DrawTestSpec::INPUTTYPE_HALF]                             = GLValue(Half::create(-256.0f));
 634
 635         return rangesLo[(int)type];
 636 }
 637
 638 template<typename T>
 639 struct GLValueTypeTraits;
 640
 641 template<> struct GLValueTypeTraits<GLValue::Float>      { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_FLOAT;                   };
 642 template<> struct GLValueTypeTraits<GLValue::Double> { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_DOUBLE;                      };
 643 template<> struct GLValueTypeTraits<GLValue::Byte>       { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_BYTE;                    };
 644 template<> struct GLValueTypeTraits<GLValue::Ubyte>      { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE;   };
 645 template<> struct GLValueTypeTraits<GLValue::Ushort> { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT;      };
 646 template<> struct GLValueTypeTraits<GLValue::Short>      { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_SHORT;                   };
 647 template<> struct GLValueTypeTraits<GLValue::Fixed>      { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_FIXED;                   };
 648 template<> struct GLValueTypeTraits<GLValue::Int>        { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_INT;                     };
 649 template<> struct GLValueTypeTraits<GLValue::Uint>       { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_UNSIGNED_INT;    };
 650 template<> struct GLValueTypeTraits<GLValue::Half>       { static const DrawTestSpec::InputType Type = DrawTestSpec::INPUTTYPE_HALF;                    };
 651
 652 template<typename T>
 653 inline T extractGLValue (const GLValue& v);
 654
 655 template<> GLValue::Float       inline extractGLValue<GLValue::Float>           (const GLValue& v) { return v.fl; };
 656 template<> GLValue::Double      inline extractGLValue<GLValue::Double>          (const GLValue& v) { return v.d; };
 657 template<> GLValue::Byte        inline extractGLValue<GLValue::Byte>            (const GLValue& v) { return v.b; };
 658 template<> GLValue::Ubyte       inline extractGLValue<GLValue::Ubyte>           (const GLValue& v) { return v.ub; };
 659 template<> GLValue::Ushort      inline extractGLValue<GLValue::Ushort>          (const GLValue& v) { return v.us; };
 660 template<> GLValue::Short       inline extractGLValue<GLValue::Short>           (const GLValue& v) { return v.s; };
 661 template<> GLValue::Fixed       inline extractGLValue<GLValue::Fixed>           (const GLValue& v) { return v.fi; };
 662 template<> GLValue::Int         inline extractGLValue<GLValue::Int>                     (const GLValue& v) { return v.i; };
 663 template<> GLValue::Uint        inline extractGLValue<GLValue::Uint>            (const GLValue& v) { return v.ui; };
 664 template<> GLValue::Half        inline extractGLValue<GLValue::Half>            (const GLValue& v) { return v.h; };
 665
 666 template<class T>
 667 inline T getRandom (deRandom& rnd, T min, T max);
 668
 669 template<>
 670 inline GLValue::Float getRandom (deRandom& rnd, GLValue::Float min, GLValue::Float max)
 671 {
 672         if (max < min)
 673                 return min;
 674
 675         return GLValue::Float::create(min + deRandom_getFloat(&rnd) * (max.to<float>() - min.to<float>()));
 676 }
 677
 678 template<>
 679 inline GLValue::Double getRandom (deRandom& rnd, GLValue::Double min, GLValue::Double max)
 680 {
 681         if (max < min)
 682                 return min;
 683
 684         return GLValue::Double::create(min + deRandom_getFloat(&rnd) * (max.to<float>() - min.to<float>()));
 685 }
 686
 687 template<>
 688 inline GLValue::Short getRandom (deRandom& rnd, GLValue::Short min, GLValue::Short max)
 689 {
 690         if (max < min)
 691                 return min;
 692
 693         return GLValue::Short::create((min == max ? min : (deInt16)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
 694 }
 695
 696 template<>
 697 inline GLValue::Ushort getRandom (deRandom& rnd, GLValue::Ushort min, GLValue::Ushort max)
 698 {
 699         if (max < min)
 700                 return min;
 701
 702         return GLValue::Ushort::create((min == max ? min : (deUint16)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
 703 }
 704
 705 template<>
 706 inline GLValue::Byte getRandom (deRandom& rnd, GLValue::Byte min, GLValue::Byte max)
 707 {
 708         if (max < min)
 709                 return min;
 710
 711         return GLValue::Byte::create((min == max ? min : (deInt8)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
 712 }
 713
 714 template<>
 715 inline GLValue::Ubyte getRandom (deRandom& rnd, GLValue::Ubyte min, GLValue::Ubyte max)
 716 {
 717         if (max < min)
 718                 return min;
 719
 720         return GLValue::Ubyte::create((min == max ? min : (deUint8)(min + (deRandom_getUint32(&rnd) % (max.to<int>() - min.to<int>())))));
 721 }
 722
 723 template<>
 724 inline GLValue::Fixed getRandom (deRandom& rnd, GLValue::Fixed min, GLValue::Fixed max)
 725 {
 726         if (max < min)
 727                 return min;
 728
 729         return GLValue::Fixed::create((min == max ? min : min + (deRandom_getUint32(&rnd) % (max.to<deUint32>() - min.to<deUint32>()))));
 730 }
 731
 732 template<>
 733 inline GLValue::Half getRandom (deRandom& rnd, GLValue::Half min, GLValue::Half max)
 734 {
 735         if (max < min)
 736                 return min;
 737
 738         float fMax = max.to<float>();
 739         float fMin = min.to<float>();
 740         GLValue::Half h = GLValue::Half::create(fMin + deRandom_getFloat(&rnd) * (fMax - fMin));
 741         return h;
 742 }
 743
 744 template<>
 745 inline GLValue::Int getRandom (deRandom& rnd, GLValue::Int min, GLValue::Int max)
 746 {
 747         if (max < min)
 748                 return min;
 749
 750         return GLValue::Int::create((min == max ? min : min + (deRandom_getUint32(&rnd) % (max.to<deUint32>() - min.to<deUint32>()))));
 751 }
 752
 753 template<>
 754 inline GLValue::Uint getRandom (deRandom& rnd, GLValue::Uint min, GLValue::Uint max)
 755 {
 756         if (max < min)
 757                 return min;
 758
 759         return GLValue::Uint::create((min == max ? min : min + (deRandom_getUint32(&rnd) % (max.to<deUint32>() - min.to<deUint32>()))));
 760 }
 761
 762 // Minimum difference required between coordinates
 763 template<class T>
 764 inline T minValue (void);
 765
 766 template<>
 767 inline GLValue::Float minValue (void)
 768 {
 769         return GLValue::Float::create(4 * 1.0f);
 770 }
 771
 772 template<>
 773 inline GLValue::Double minValue (void)
 774 {
 775         return GLValue::Double::create(4 * 1.0f);
 776 }
 777
 778 template<>
 779 inline GLValue::Short minValue (void)
 780 {
 781         return GLValue::Short::create(4 * 256);
 782 }
 783
 784 template<>
 785 inline GLValue::Ushort minValue (void)
 786 {
 787         return GLValue::Ushort::create(4 * 256);
 788 }
 789
 790 template<>
 791 inline GLValue::Byte minValue (void)
 792 {
 793         return GLValue::Byte::create(4 * 1);
 794 }
 795
 796 template<>
 797 inline GLValue::Ubyte minValue (void)
 798 {
 799         return GLValue::Ubyte::create(4 * 2);
 800 }
 801
 802 template<>
 803 inline GLValue::Fixed minValue (void)
 804 {
 805         return GLValue::Fixed::create(4 * 1);
 806 }
 807
 808 template<>
 809 inline GLValue::Int minValue (void)
 810 {
 811         return GLValue::Int::create(4 * 16777216);
 812 }
 813
 814 template<>
 815 inline GLValue::Uint minValue (void)
 816 {
 817         return GLValue::Uint::create(4 * 16777216);
 818 }
 819
 820 template<>
 821 inline GLValue::Half minValue (void)
 822 {
 823         return GLValue::Half::create(4 * 1.0f);
 824 }
 825
 826 template<class T>
 827 inline T abs (T val);
 828
 829 template<>
 830 inline GLValue::Fixed abs (GLValue::Fixed val)
 831 {
 832         return GLValue::Fixed::create(0x7FFFu & val.getValue());
 833 }
 834
 835 template<>
 836 inline GLValue::Ubyte abs (GLValue::Ubyte val)
 837 {
 838         return val;
 839 }
 840
 841 template<>
 842 inline GLValue::Byte abs (GLValue::Byte val)
 843 {
 844         return GLValue::Byte::create(0x7Fu & val.getValue());
 845 }
 846
 847 template<>
 848 inline GLValue::Ushort abs (GLValue::Ushort val)
 849 {
 850         return val;
 851 }
 852
 853 template<>
 854 inline GLValue::Short abs (GLValue::Short val)
 855 {
 856         return GLValue::Short::create(0x7FFFu & val.getValue());
 857 }
 858
 859 template<>
 860 inline GLValue::Float abs (GLValue::Float val)
 861 {
 862         return GLValue::Float::create(std::fabs(val.to<float>()));
 863 }
 864
 865 template<>
 866 inline GLValue::Double abs (GLValue::Double val)
 867 {
 868         return GLValue::Double::create(std::fabs(val.to<float>()));
 869 }
 870
 871 template<>
 872 inline GLValue::Uint abs (GLValue::Uint val)
 873 {
 874         return val;
 875 }
 876
 877 template<>
 878 inline GLValue::Int abs (GLValue::Int val)
 879 {
 880         return GLValue::Int::create(0x7FFFFFFFu & val.getValue());
 881 }
 882
 883 template<>
 884 inline GLValue::Half abs (GLValue::Half val)
 885 {
 886         return GLValue::Half::create(std::fabs(val.to<float>()));
 887 }
 888
 889 // AttributeArray
 890
 891 class AttributeArray
 892 {
 893 public:
 894                                                                 AttributeArray          (DrawTestSpec::Storage storage, sglr::Context& context);
 895                                                                 ~AttributeArray         (void);
 896
 897         void                                            data                            (DrawTestSpec::Target target, size_t size, const char* data, DrawTestSpec::Usage usage);
 898         void                                            setupArray                      (bool bound, int offset, int size, DrawTestSpec::InputType inType, DrawTestSpec::OutputType outType, bool normalized, int stride, int instanceDivisor, const rr::GenericVec4& defaultAttrib, bool isPositionAttr, bool bgraComponentOrder);
 899         void                                            bindAttribute           (deUint32 loc);
 900         void                                            bindIndexArray          (DrawTestSpec::Target storage);
 901
 902         int                                                     getComponentCount       (void) const { return m_componentCount; }
 903         DrawTestSpec::Target            getTarget                       (void) const { return m_target; }
 904         DrawTestSpec::InputType         getInputType            (void) const { return m_inputType; }
 905         DrawTestSpec::OutputType        getOutputType           (void) const { return m_outputType; }
 906         DrawTestSpec::Storage           getStorageType          (void) const { return m_storage; }
 907         bool                                            getNormalized           (void) const { return m_normalize; }
 908         int                                                     getStride                       (void) const { return m_stride; }
 909         bool                                            isBound                         (void) const { return m_bound; }
 910         bool                                            isPositionAttribute     (void) const { return m_isPositionAttr; }
 911
 912 private:
 913         DrawTestSpec::Storage           m_storage;
 914         sglr::Context&                          m_ctx;
 915         deUint32                                        m_glBuffer;
 916
 917         int                                                     m_size;
 918         char*                                           m_data;
 919         int                                                     m_componentCount;
 920         bool                                            m_bound;
 921         DrawTestSpec::Target            m_target;
 922         DrawTestSpec::InputType         m_inputType;
 923         DrawTestSpec::OutputType        m_outputType;
 924         bool                                            m_normalize;
 925         int                                                     m_stride;
 926         int                                                     m_offset;
 927         rr::GenericVec4                         m_defaultAttrib;
 928         int                                                     m_instanceDivisor;
 929         bool                                            m_isPositionAttr;
 930         bool                                            m_bgraOrder;
 931 };
 932
 933 AttributeArray::AttributeArray (DrawTestSpec::Storage storage, sglr::Context& context)
 934         : m_storage                     (storage)
 935         , m_ctx                         (context)
 936         , m_glBuffer            (0)
 937         , m_size                        (0)
 938         , m_data                        (DE_NULL)
 939         , m_componentCount      (1)
 940         , m_bound                       (false)
 941         , m_target                      (DrawTestSpec::TARGET_ARRAY)
 942         , m_inputType           (DrawTestSpec::INPUTTYPE_FLOAT)
 943         , m_outputType          (DrawTestSpec::OUTPUTTYPE_VEC4)
 944         , m_normalize           (false)
 945         , m_stride                      (0)
 946         , m_offset                      (0)
 947         , m_instanceDivisor     (0)
 948         , m_isPositionAttr      (false)
 949         , m_bgraOrder           (false)
 950 {
 951         if (m_storage == DrawTestSpec::STORAGE_BUFFER)
 952         {
 953                 m_ctx.genBuffers(1, &m_glBuffer);
 954                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glGenBuffers()");
 955         }
 956 }
 957
 958 AttributeArray::~AttributeArray (void)
 959 {
 960         if (m_storage == DrawTestSpec::STORAGE_BUFFER)
 961         {
 962                 m_ctx.deleteBuffers(1, &m_glBuffer);
 963                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDeleteBuffers()");
 964         }
 965         else if (m_storage == DrawTestSpec::STORAGE_USER)
 966                 delete[] m_data;
 967         else
 968                 DE_ASSERT(false);
 969 }
 970
 971 void AttributeArray::data (DrawTestSpec::Target target, size_t size, const char* ptr, DrawTestSpec::Usage usage)
 972 {
 973         m_size = (int)size;
 974         m_target = target;
 975
 976         if (m_storage == DrawTestSpec::STORAGE_BUFFER)
 977         {
 978                 m_ctx.bindBuffer(targetToGL(target), m_glBuffer);
 979                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");
 980
 981                 m_ctx.bufferData(targetToGL(target), size, ptr, usageToGL(usage));
 982                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBufferData()");
 983         }
 984         else if (m_storage == DrawTestSpec::STORAGE_USER)
 985         {
 986                 if (m_data)
 987                         delete[] m_data;
 988
 989                 m_data = new char[size];
 990                 std::memcpy(m_data, ptr, size);
 991         }
 992         else
 993                 DE_ASSERT(false);
 994 }
 995
 996 void AttributeArray::setupArray (bool bound, int offset, int size, DrawTestSpec::InputType inputType, DrawTestSpec::OutputType outType, bool normalized, int stride, int instanceDivisor, const rr::GenericVec4& defaultAttrib, bool isPositionAttr, bool bgraComponentOrder)
 997 {
 998         m_componentCount        = size;
 999         m_bound                         = bound;
1000         m_inputType                     = inputType;
1001         m_outputType            = outType;
1002         m_normalize                     = normalized;
1003         m_stride                        = stride;
1004         m_offset                        = offset;
1005         m_defaultAttrib         = defaultAttrib;
1006         m_instanceDivisor       = instanceDivisor;
1007         m_isPositionAttr        = isPositionAttr;
1008         m_bgraOrder                     = bgraComponentOrder;
1009 }
1010
1011 void AttributeArray::bindAttribute (deUint32 loc)
1012 {
1013         if (!isBound())
1014         {
1015                 switch (m_inputType)
1016                 {
1017                         case DrawTestSpec::INPUTTYPE_FLOAT:
1018                         {
1019                                 tcu::Vec4 attr = m_defaultAttrib.get<float>();
1020
1021                                 switch (m_componentCount)
1022                                 {
1023                                         case 1: m_ctx.vertexAttrib1f(loc, attr.x()); break;
1024                                         case 2: m_ctx.vertexAttrib2f(loc, attr.x(), attr.y()); break;
1025                                         case 3: m_ctx.vertexAttrib3f(loc, attr.x(), attr.y(), attr.z()); break;
1026                                         case 4: m_ctx.vertexAttrib4f(loc, attr.x(), attr.y(), attr.z(), attr.w()); break;
1027                                         default: DE_ASSERT(DE_FALSE); break;
1028                                 }
1029                                 break;
1030                         }
1031                         case DrawTestSpec::INPUTTYPE_INT:
1032                         {
1033                                 tcu::IVec4 attr = m_defaultAttrib.get<deInt32>();
1034                                 m_ctx.vertexAttribI4i(loc, attr.x(), attr.y(), attr.z(), attr.w());
1035                                 break;
1036                         }
1037                         case DrawTestSpec::INPUTTYPE_UNSIGNED_INT:
1038                         {
1039                                 tcu::UVec4 attr = m_defaultAttrib.get<deUint32>();
1040                                 m_ctx.vertexAttribI4ui(loc, attr.x(), attr.y(), attr.z(), attr.w());
1041                                 break;
1042                         }
1043                         default:
1044                                 DE_ASSERT(DE_FALSE);
1045                                 break;
1046                 }
1047         }
1048         else
1049         {
1050                 const deUint8* basePtr = DE_NULL;
1051
1052                 if (m_storage == DrawTestSpec::STORAGE_BUFFER)
1053                 {
1054                         m_ctx.bindBuffer(targetToGL(m_target), m_glBuffer);
1055                         GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");
1056
1057                         basePtr = DE_NULL;
1058                 }
1059                 else if (m_storage == DrawTestSpec::STORAGE_USER)
1060                 {
1061                         m_ctx.bindBuffer(targetToGL(m_target), 0);
1062                         GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glBindBuffer()");
1063
1064                         basePtr = (const deUint8*)m_data;
1065                 }
1066                 else
1067                         DE_ASSERT(DE_FALSE);
1068
1069                 if (!inputTypeIsFloatType(m_inputType))
1070                 {
1071                         // Input is not float type
1072
1073                         if (outputTypeIsFloatType(m_outputType))
1074                         {
1075                                 const int size = (m_bgraOrder) ? (GL_BGRA) : (m_componentCount);
1076
1077                                 DE_ASSERT(!(m_bgraOrder && m_componentCount != 4));
1078
1079                                 // Output type is float type
1080                                 m_ctx.vertexAttribPointer(loc, size, inputTypeToGL(m_inputType), m_normalize, m_stride, basePtr + m_offset);
1081                                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribPointer()");
1082                         }
1083                         else
1084                         {
1085                                 // Output type is int type
1086                                 m_ctx.vertexAttribIPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_stride, basePtr + m_offset);
1087                                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribIPointer()");
1088                         }
1089                 }
1090                 else
1091                 {
1092                         // Input type is float type
1093
1094                         // Output type must be float type
1095                         DE_ASSERT(outputTypeIsFloatType(m_outputType));
1096
1097                         m_ctx.vertexAttribPointer(loc, m_componentCount, inputTypeToGL(m_inputType), m_normalize, m_stride, basePtr + m_offset);
1098                         GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glVertexAttribPointer()");
1099                 }
1100
1101                 if (m_instanceDivisor)
1102                         m_ctx.vertexAttribDivisor(loc, m_instanceDivisor);
1103         }
1104 }
1105
1106 void AttributeArray::bindIndexArray (DrawTestSpec::Target target)
1107 {
1108         if (m_storage == DrawTestSpec::STORAGE_USER)
1109         {
1110         }
1111         else if (m_storage == DrawTestSpec::STORAGE_BUFFER)
1112         {
1113                 m_ctx.bindBuffer(targetToGL(target), m_glBuffer);
1114         }
1115 }
1116
1117 // DrawTestShaderProgram
1118
1119 class DrawTestShaderProgram : public sglr::ShaderProgram
1120 {
1121 public:
1122                                                                                                 DrawTestShaderProgram           (const glu::RenderContext& ctx, const std::vector<AttributeArray*>& arrays);
1123
1124         void                                                                            shadeVertices                           (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const;
1125         void                                                                            shadeFragments                          (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const;
1126
1127 private:
1128         static std::string                                                      genVertexSource                         (const glu::RenderContext& ctx, const std::vector<AttributeArray*>& arrays);
1129         static std::string                                                      genFragmentSource                       (const glu::RenderContext& ctx);
1130         static void                                                                     generateShaderParams            (std::map<std::string, std::string>& params, glu::ContextType type);
1131         static rr::GenericVecType                                       mapOutputType                           (const DrawTestSpec::OutputType& type);
1132         static int                                                                      getComponentCount                       (const DrawTestSpec::OutputType& type);
1133
1134         static sglr::pdec::ShaderProgramDeclaration createProgramDeclaration    (const glu::RenderContext& ctx, const std::vector<AttributeArray*>& arrays);
1135
1136         std::vector<int>                                                        m_componentCount;
1137         std::vector<bool>                                                       m_isCoord;
1138         std::vector<rr::GenericVecType>                         m_attrType;
1139 };
1140
1141 DrawTestShaderProgram::DrawTestShaderProgram (const glu::RenderContext& ctx, const std::vector<AttributeArray*>& arrays)
1142         : sglr::ShaderProgram   (createProgramDeclaration(ctx, arrays))
1143         , m_componentCount              (arrays.size())
1144         , m_isCoord                             (arrays.size())
1145         , m_attrType                    (arrays.size())
1146 {
1147         for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
1148         {
1149                 m_componentCount[arrayNdx]      = getComponentCount(arrays[arrayNdx]->getOutputType());
1150                 m_isCoord[arrayNdx]                     = arrays[arrayNdx]->isPositionAttribute();
1151                 m_attrType[arrayNdx]            = mapOutputType(arrays[arrayNdx]->getOutputType());
1152         }
1153 }
1154
1155 template <typename T>
1156 void calcShaderColorCoord (tcu::Vec2& coord, tcu::Vec3& color, const tcu::Vector<T, 4>& attribValue, bool isCoordinate, int numComponents)
1157 {
1158         if (isCoordinate)
1159                 switch (numComponents)
1160                 {
1161                         case 1: coord += tcu::Vec2((float)attribValue.x(),                                                      (float)attribValue.x());                                                        break;
1162                         case 2: coord += tcu::Vec2((float)attribValue.x(),                                                      (float)attribValue.y());                                                        break;
1163                         case 3: coord += tcu::Vec2((float)attribValue.x() + (float)attribValue.z(),     (float)attribValue.y());                                                        break;
1164                         case 4: coord += tcu::Vec2((float)attribValue.x() + (float)attribValue.z(),     (float)attribValue.y() + (float)attribValue.w());       break;
1165
1166                         default:
1167                                 DE_ASSERT(false);
1168                 }
1169         else
1170         {
1171                 switch (numComponents)
1172                 {
1173                         case 1:
1174                                 color = color * (float)attribValue.x();
1175                                 break;
1176
1177                         case 2:
1178                                 color.x() = color.x() * (float)attribValue.x();
1179                                 color.y() = color.y() * (float)attribValue.y();
1180                                 break;
1181
1182                         case 3:
1183                                 color.x() = color.x() * (float)attribValue.x();
1184                                 color.y() = color.y() * (float)attribValue.y();
1185                                 color.z() = color.z() * (float)attribValue.z();
1186                                 break;
1187
1188                         case 4:
1189                                 color.x() = color.x() * (float)attribValue.x() * (float)attribValue.w();
1190                                 color.y() = color.y() * (float)attribValue.y() * (float)attribValue.w();
1191                                 color.z() = color.z() * (float)attribValue.z() * (float)attribValue.w();
1192                                 break;
1193
1194                         default:
1195                                 DE_ASSERT(false);
1196                 }
1197         }
1198 }
1199
1200 void DrawTestShaderProgram::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
1201 {
1202         const float     u_coordScale = getUniformByName("u_coordScale").value.f;
1203         const float u_colorScale = getUniformByName("u_colorScale").value.f;
1204
1205         for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
1206         {
1207                 const size_t varyingLocColor = 0;
1208
1209                 rr::VertexPacket& packet = *packets[packetNdx];
1210
1211                 // Calc output color
1212                 tcu::Vec2 coord = tcu::Vec2(0.0, 0.0);
1213                 tcu::Vec3 color = tcu::Vec3(1.0, 1.0, 1.0);
1214
1215                 for (int attribNdx = 0; attribNdx < (int)m_attrType.size(); attribNdx++)
1216                 {
1217                         const int       numComponents   = m_componentCount[attribNdx];
1218                         const bool      isCoord                 = m_isCoord[attribNdx];
1219
1220                         switch (m_attrType[attribNdx])
1221                         {
1222                                 case rr::GENERICVECTYPE_FLOAT:  calcShaderColorCoord(coord, color, rr::readVertexAttribFloat(inputs[attribNdx], packet.instanceNdx, packet.vertexNdx), isCoord, numComponents); break;
1223                                 case rr::GENERICVECTYPE_INT32:  calcShaderColorCoord(coord, color, rr::readVertexAttribInt      (inputs[attribNdx], packet.instanceNdx, packet.vertexNdx), isCoord, numComponents);     break;
1224                                 case rr::GENERICVECTYPE_UINT32: calcShaderColorCoord(coord, color, rr::readVertexAttribUint     (inputs[attribNdx], packet.instanceNdx, packet.vertexNdx), isCoord, numComponents);     break;
1225                                 default:
1226                                         DE_ASSERT(false);
1227                         }
1228                 }
1229
1230                 // Transform position
1231                 {
1232                         packet.position = tcu::Vec4(u_coordScale * coord.x(), u_coordScale * coord.y(), 1.0f, 1.0f);
1233                         packet.pointSize = 1.0f;
1234                 }
1235
1236                 // Pass color to FS
1237                 {
1238                         packet.outputs[varyingLocColor] = tcu::Vec4(u_colorScale * color.x(), u_colorScale * color.y(), u_colorScale * color.z(), 1.0f) * 0.5f + tcu::Vec4(0.5f, 0.5f, 0.5f, 0.5f);
1239                 }
1240         }
1241 }
1242
1243 void DrawTestShaderProgram::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
1244 {
1245         const size_t varyingLocColor = 0;
1246
1247         for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
1248         {
1249                 rr::FragmentPacket& packet = packets[packetNdx];
1250
1251                 for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
1252                         rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, rr::readVarying<float>(packet, context, varyingLocColor, fragNdx));
1253         }
1254 }
1255
1256 std::string DrawTestShaderProgram::genVertexSource (const glu::RenderContext& ctx, const std::vector<AttributeArray*>& arrays)
1257 {
1258         std::map<std::string, std::string>      params;
1259         std::stringstream                                       vertexShaderTmpl;
1260
1261         generateShaderParams(params, ctx.getType());
1262
1263         vertexShaderTmpl << "${VTX_HDR}";
1264
1265         for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
1266         {
1267                 vertexShaderTmpl
1268                         << "${VTX_IN} highp " << outputTypeToGLType(arrays[arrayNdx]->getOutputType()) << " a_" << arrayNdx << ";\n";
1269         }
1270
1271         vertexShaderTmpl <<
1272                 "uniform highp float u_coordScale;\n"
1273                 "uniform highp float u_colorScale;\n"
1274                 "${VTX_OUT} ${COL_PRECISION} vec4 v_color;\n"
1275                 "void main(void)\n"
1276                 "{\n"
1277                 "\tgl_PointSize = 1.0;\n"
1278                 "\thighp vec2 coord = vec2(0.0, 0.0);\n"
1279                 "\thighp vec3 color = vec3(1.0, 1.0, 1.0);\n";
1280
1281         for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
1282         {
1283                 const bool isPositionAttr = arrays[arrayNdx]->isPositionAttribute();
1284
1285                 if (isPositionAttr)
1286                 {
1287                         switch (arrays[arrayNdx]->getOutputType())
1288                         {
1289                                 case (DrawTestSpec::OUTPUTTYPE_FLOAT):
1290                                 case (DrawTestSpec::OUTPUTTYPE_INT):
1291                                 case (DrawTestSpec::OUTPUTTYPE_UINT):
1292                                         vertexShaderTmpl <<
1293                                                 "\tcoord += vec2(float(a_" << arrayNdx << "), float(a_" << arrayNdx << "));\n";
1294                                         break;
1295
1296                                 case (DrawTestSpec::OUTPUTTYPE_VEC2):
1297                                 case (DrawTestSpec::OUTPUTTYPE_IVEC2):
1298                                 case (DrawTestSpec::OUTPUTTYPE_UVEC2):
1299                                         vertexShaderTmpl <<
1300                                                 "\tcoord += vec2(a_" << arrayNdx << ".xy);\n";
1301                                         break;
1302
1303                                 case (DrawTestSpec::OUTPUTTYPE_VEC3):
1304                                 case (DrawTestSpec::OUTPUTTYPE_IVEC3):
1305                                 case (DrawTestSpec::OUTPUTTYPE_UVEC3):
1306                                         vertexShaderTmpl <<
1307                                                 "\tcoord += vec2(a_" << arrayNdx << ".xy);\n"
1308                                                 "\tcoord.x += float(a_" << arrayNdx << ".z);\n";
1309                                         break;
1310
1311                                 case (DrawTestSpec::OUTPUTTYPE_VEC4):
1312                                 case (DrawTestSpec::OUTPUTTYPE_IVEC4):
1313                                 case (DrawTestSpec::OUTPUTTYPE_UVEC4):
1314                                         vertexShaderTmpl <<
1315                                                 "\tcoord += vec2(a_" << arrayNdx << ".xy);\n"
1316                                                 "\tcoord += vec2(a_" << arrayNdx << ".zw);\n";
1317                                         break;
1318
1319                                 default:
1320                                         DE_ASSERT(false);
1321                                         break;
1322                         }
1323                 }
1324                 else
1325                 {
1326                         switch (arrays[arrayNdx]->getOutputType())
1327                         {
1328                                 case (DrawTestSpec::OUTPUTTYPE_FLOAT):
1329                                 case (DrawTestSpec::OUTPUTTYPE_INT):
1330                                 case (DrawTestSpec::OUTPUTTYPE_UINT):
1331                                         vertexShaderTmpl <<
1332                                                 "\tcolor = color * float(a_" << arrayNdx << ");\n";
1333                                         break;
1334
1335                                 case (DrawTestSpec::OUTPUTTYPE_VEC2):
1336                                 case (DrawTestSpec::OUTPUTTYPE_IVEC2):
1337                                 case (DrawTestSpec::OUTPUTTYPE_UVEC2):
1338                                         vertexShaderTmpl <<
1339                                                 "\tcolor.rg = color.rg * vec2(a_" << arrayNdx << ".xy);\n";
1340                                         break;
1341
1342                                 case (DrawTestSpec::OUTPUTTYPE_VEC3):
1343                                 case (DrawTestSpec::OUTPUTTYPE_IVEC3):
1344                                 case (DrawTestSpec::OUTPUTTYPE_UVEC3):
1345                                         vertexShaderTmpl <<
1346                                                 "\tcolor = color.rgb * vec3(a_" << arrayNdx << ".xyz);\n";
1347                                         break;
1348
1349                                 case (DrawTestSpec::OUTPUTTYPE_VEC4):
1350                                 case (DrawTestSpec::OUTPUTTYPE_IVEC4):
1351                                 case (DrawTestSpec::OUTPUTTYPE_UVEC4):
1352                                         vertexShaderTmpl <<
1353                                                 "\tcolor = color.rgb * vec3(a_" << arrayNdx << ".xyz) * float(a_" << arrayNdx << ".w);\n";
1354                                         break;
1355
1356                                 default:
1357                                         DE_ASSERT(false);
1358                                         break;
1359                         }
1360                 }
1361         }
1362
1363         vertexShaderTmpl <<
1364                 "\tv_color = vec4(u_colorScale * color, 1.0) * 0.5 + vec4(0.5, 0.5, 0.5, 0.5);\n"
1365                 "\tgl_Position = vec4(u_coordScale * coord, 1.0, 1.0);\n"
1366                 "}\n";
1367
1368         return tcu::StringTemplate(vertexShaderTmpl.str().c_str()).specialize(params);
1369 }
1370
1371 std::string DrawTestShaderProgram::genFragmentSource (const glu::RenderContext& ctx)
1372 {
1373         std::map<std::string, std::string> params;
1374
1375         generateShaderParams(params, ctx.getType());
1376
1377         static const char* fragmentShaderTmpl =
1378                 "${FRAG_HDR}"
1379                 "${FRAG_IN} ${COL_PRECISION} vec4 v_color;\n"
1380                 "void main(void)\n"
1381                 "{\n"
1382                 "\t${FRAG_COLOR} = v_color;\n"
1383                 "}\n";
1384
1385         return tcu::StringTemplate(fragmentShaderTmpl).specialize(params);
1386 }
1387
1388 void DrawTestShaderProgram::generateShaderParams (std::map<std::string, std::string>& params, glu::ContextType type)
1389 {
1390         if (glu::isGLSLVersionSupported(type, glu::GLSL_VERSION_300_ES))
1391         {
1392                 params["VTX_IN"]                = "in";
1393                 params["VTX_OUT"]               = "out";
1394                 params["FRAG_IN"]               = "in";
1395                 params["FRAG_COLOR"]    = "dEQP_FragColor";
1396                 params["VTX_HDR"]               = "#version 300 es\n";
1397                 params["FRAG_HDR"]              = "#version 300 es\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n";
1398                 params["COL_PRECISION"] = "mediump";
1399         }
1400         else if (glu::isGLSLVersionSupported(type, glu::GLSL_VERSION_100_ES))
1401         {
1402                 params["VTX_IN"]                = "attribute";
1403                 params["VTX_OUT"]               = "varying";
1404                 params["FRAG_IN"]               = "varying";
1405                 params["FRAG_COLOR"]    = "gl_FragColor";
1406                 params["VTX_HDR"]               = "";
1407                 params["FRAG_HDR"]              = "";
1408                 params["COL_PRECISION"] = "mediump";
1409         }
1410         else if (glu::isGLSLVersionSupported(type, glu::GLSL_VERSION_430))
1411         {
1412                 params["VTX_IN"]                = "in";
1413                 params["VTX_OUT"]               = "out";
1414                 params["FRAG_IN"]               = "in";
1415                 params["FRAG_COLOR"]    = "dEQP_FragColor";
1416                 params["VTX_HDR"]               = "#version 430\n";
1417                 params["FRAG_HDR"]              = "#version 430\nlayout(location = 0) out highp vec4 dEQP_FragColor;\n";
1418                 params["COL_PRECISION"] = "highp";
1419         }
1420         else if (glu::isGLSLVersionSupported(type, glu::GLSL_VERSION_330))
1421         {
1422                 params["VTX_IN"]                = "in";
1423                 params["VTX_OUT"]               = "out";
1424                 params["FRAG_IN"]               = "in";
1425                 params["FRAG_COLOR"]    = "dEQP_FragColor";
1426                 params["VTX_HDR"]               = "#version 330\n";
1427                 params["FRAG_HDR"]              = "#version 330\nlayout(location = 0) out mediump vec4 dEQP_FragColor;\n";
1428                 params["COL_PRECISION"] = "mediump";
1429         }
1430         else
1431                 DE_ASSERT(DE_FALSE);
1432 }
1433
1434 rr::GenericVecType DrawTestShaderProgram::mapOutputType (const DrawTestSpec::OutputType& type)
1435 {
1436         switch (type)
1437         {
1438                 case (DrawTestSpec::OUTPUTTYPE_FLOAT):
1439                 case (DrawTestSpec::OUTPUTTYPE_VEC2):
1440                 case (DrawTestSpec::OUTPUTTYPE_VEC3):
1441                 case (DrawTestSpec::OUTPUTTYPE_VEC4):
1442                         return rr::GENERICVECTYPE_FLOAT;
1443
1444                 case (DrawTestSpec::OUTPUTTYPE_INT):
1445                 case (DrawTestSpec::OUTPUTTYPE_IVEC2):
1446                 case (DrawTestSpec::OUTPUTTYPE_IVEC3):
1447                 case (DrawTestSpec::OUTPUTTYPE_IVEC4):
1448                         return rr::GENERICVECTYPE_INT32;
1449
1450                 case (DrawTestSpec::OUTPUTTYPE_UINT):
1451                 case (DrawTestSpec::OUTPUTTYPE_UVEC2):
1452                 case (DrawTestSpec::OUTPUTTYPE_UVEC3):
1453                 case (DrawTestSpec::OUTPUTTYPE_UVEC4):
1454                         return rr::GENERICVECTYPE_UINT32;
1455
1456                 default:
1457                         DE_ASSERT(false);
1458                         return rr::GENERICVECTYPE_LAST;
1459         }
1460 }
1461
1462 int DrawTestShaderProgram::getComponentCount (const DrawTestSpec::OutputType& type)
1463 {
1464         switch (type)
1465         {
1466                 case (DrawTestSpec::OUTPUTTYPE_FLOAT):
1467                 case (DrawTestSpec::OUTPUTTYPE_INT):
1468                 case (DrawTestSpec::OUTPUTTYPE_UINT):
1469                         return 1;
1470
1471                 case (DrawTestSpec::OUTPUTTYPE_VEC2):
1472                 case (DrawTestSpec::OUTPUTTYPE_IVEC2):
1473                 case (DrawTestSpec::OUTPUTTYPE_UVEC2):
1474                         return 2;
1475
1476                 case (DrawTestSpec::OUTPUTTYPE_VEC3):
1477                 case (DrawTestSpec::OUTPUTTYPE_IVEC3):
1478                 case (DrawTestSpec::OUTPUTTYPE_UVEC3):
1479                         return 3;
1480
1481                 case (DrawTestSpec::OUTPUTTYPE_VEC4):
1482                 case (DrawTestSpec::OUTPUTTYPE_IVEC4):
1483                 case (DrawTestSpec::OUTPUTTYPE_UVEC4):
1484                         return 4;
1485
1486                 default:
1487                         DE_ASSERT(false);
1488                         return 0;
1489         }
1490 }
1491
1492 sglr::pdec::ShaderProgramDeclaration DrawTestShaderProgram::createProgramDeclaration (const glu::RenderContext& ctx, const std::vector<AttributeArray*>& arrays)
1493 {
1494         sglr::pdec::ShaderProgramDeclaration decl;
1495
1496         for (int arrayNdx = 0; arrayNdx < (int)arrays.size(); arrayNdx++)
1497                 decl << sglr::pdec::VertexAttribute(std::string("a_") + de::toString(arrayNdx), mapOutputType(arrays[arrayNdx]->getOutputType()));
1498
1499         decl << sglr::pdec::VertexToFragmentVarying(rr::GENERICVECTYPE_FLOAT);
1500         decl << sglr::pdec::FragmentOutput(rr::GENERICVECTYPE_FLOAT);
1501
1502         decl << sglr::pdec::VertexSource(genVertexSource(ctx, arrays));
1503         decl << sglr::pdec::FragmentSource(genFragmentSource(ctx));
1504
1505         decl << sglr::pdec::Uniform("u_coordScale", glu::TYPE_FLOAT);
1506         decl << sglr::pdec::Uniform("u_colorScale", glu::TYPE_FLOAT);
1507
1508         return decl;
1509 }
1510
1511 class RandomArrayGenerator
1512 {
1513 public:
1514         static char*                    generateArray                   (int seed, int elementCount, int componentCount, int offset, int stride, DrawTestSpec::InputType type);
1515         static char*                    generateIndices                 (int seed, int elementCount, DrawTestSpec::IndexType type, int offset, int min, int max, int indexBase);
1516         static rr::GenericVec4  generateAttributeValue  (int seed, DrawTestSpec::InputType type);
1517
1518 private:
1519         template<typename T>
1520         static char*                    createIndices                   (int seed, int elementCount, int offset, int min, int max, int indexBase);
1521
1522         static char*                    generateBasicArray              (int seed, int elementCount, int componentCount, int offset, int stride, DrawTestSpec::InputType type);
1523         template<typename T, typename GLType>
1524         static char*                    createBasicArray                (int seed, int elementCount, int componentCount, int offset, int stride);
1525         static char*                    generatePackedArray             (int seed, int elementCount, int componentCount, int offset, int stride);
1526 };
1527
1528 char* RandomArrayGenerator::generateArray (int seed, int elementCount, int componentCount, int offset, int stride, DrawTestSpec::InputType type)
1529 {
1530         if (type == DrawTestSpec::INPUTTYPE_INT_2_10_10_10 || type == DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10)
1531                 return generatePackedArray(seed, elementCount, componentCount, offset, stride);
1532         else
1533                 return generateBasicArray(seed, elementCount, componentCount, offset, stride, type);
1534 }
1535
1536 char* RandomArrayGenerator::generateBasicArray (int seed, int elementCount, int componentCount, int offset, int stride, DrawTestSpec::InputType type)
1537 {
1538         switch (type)
1539         {
1540                 case DrawTestSpec::INPUTTYPE_FLOAT:                             return createBasicArray<float,          GLValue::Float> (seed, elementCount, componentCount, offset, stride);
1541                 case DrawTestSpec::INPUTTYPE_DOUBLE:                    return createBasicArray<double,         GLValue::Double>(seed, elementCount, componentCount, offset, stride);
1542                 case DrawTestSpec::INPUTTYPE_SHORT:                             return createBasicArray<deInt16,        GLValue::Short> (seed, elementCount, componentCount, offset, stride);
1543                 case DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT:    return createBasicArray<deUint16,       GLValue::Ushort>(seed, elementCount, componentCount, offset, stride);
1544                 case DrawTestSpec::INPUTTYPE_BYTE:                              return createBasicArray<deInt8,         GLValue::Byte>  (seed, elementCount, componentCount, offset, stride);
1545                 case DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE:             return createBasicArray<deUint8,        GLValue::Ubyte> (seed, elementCount, componentCount, offset, stride);
1546                 case DrawTestSpec::INPUTTYPE_FIXED:                             return createBasicArray<deInt32,        GLValue::Fixed> (seed, elementCount, componentCount, offset, stride);
1547                 case DrawTestSpec::INPUTTYPE_INT:                               return createBasicArray<deInt32,        GLValue::Int>   (seed, elementCount, componentCount, offset, stride);
1548                 case DrawTestSpec::INPUTTYPE_UNSIGNED_INT:              return createBasicArray<deUint32,       GLValue::Uint>  (seed, elementCount, componentCount, offset, stride);
1549                 case DrawTestSpec::INPUTTYPE_HALF:                              return createBasicArray<deFloat16,      GLValue::Half>  (seed, elementCount, componentCount, offset, stride);
1550                 default:
1551                         DE_ASSERT(false);
1552                         break;
1553         }
1554         return DE_NULL;
1555 }
1556
1557 #if (DE_COMPILER == DE_COMPILER_GCC) && (__GNUC__ == 4) && (__GNUC_MINOR__ >= 8)
1558         // GCC 4.8/4.9 incorrectly emits array-bounds warning from createBasicArray()
1559 #       define GCC_ARRAY_BOUNDS_FALSE_NEGATIVE 1
1560 #endif
1561
1562 #if defined(GCC_ARRAY_BOUNDS_FALSE_NEGATIVE)
1563 #       pragma GCC diagnostic push
1564 #       pragma GCC diagnostic ignored "-Warray-bounds"
1565 #endif
1566
1567 template<typename T, typename GLType>
1568 char* RandomArrayGenerator::createBasicArray (int seed, int elementCount, int componentCount, int offset, int stride)
1569 {
1570         DE_ASSERT(componentCount >= 1 && componentCount <= 4);
1571
1572         const GLType min = extractGLValue<GLType>(GLValue::getMinValue(GLValueTypeTraits<GLType>::Type));
1573         const GLType max = extractGLValue<GLType>(GLValue::getMaxValue(GLValueTypeTraits<GLType>::Type));
1574
1575         const size_t componentSize      = sizeof(T);
1576         const size_t elementSize        = componentSize * componentCount;
1577         const size_t bufferSize         = offset + (elementCount - 1) * stride + elementSize;
1578
1579         char* data = new char[bufferSize];
1580         char* writePtr = data + offset;
1581
1582         GLType previousComponents[4];
1583
1584         deRandom rnd;
1585         deRandom_init(&rnd, seed);
1586
1587         for (int vertexNdx = 0; vertexNdx < elementCount; vertexNdx++)
1588         {
1589                 GLType components[4];
1590
1591                 for (int componentNdx = 0; componentNdx < componentCount; componentNdx++)
1592                 {
1593                         components[componentNdx] = getRandom<GLType>(rnd, min, max);
1594
1595                         // Try to not create vertex near previous
1596                         if (vertexNdx != 0 && abs(components[componentNdx] - previousComponents[componentNdx]) < minValue<GLType>())
1597                         {
1598                                 // Too close, try again (but only once)
1599                                 components[componentNdx] = getRandom<GLType>(rnd, min, max);
1600                         }
1601                 }
1602
1603                 for (int componentNdx = 0; componentNdx < componentCount; componentNdx++)
1604                         previousComponents[componentNdx] = components[componentNdx];
1605
1606                 for (int componentNdx = 0; componentNdx < componentCount; componentNdx++)
1607                         alignmentSafeAssignment(writePtr + componentNdx*componentSize, components[componentNdx].getValue());
1608
1609                 writePtr += stride;
1610         }
1611
1612         return data;
1613 }
1614
1615 #if defined(GCC_ARRAY_BOUNDS_FALSE_NEGATIVE)
1616 #       pragma GCC diagnostic pop
1617 #endif
1618
1619 char* RandomArrayGenerator::generatePackedArray (int seed, int elementCount, int componentCount, int offset, int stride)
1620 {
1621         DE_ASSERT(componentCount == 4);
1622         DE_UNREF(componentCount);
1623
1624         const deUint32 limit10          = (1 << 10);
1625         const deUint32 limit2           = (1 << 2);
1626         const size_t elementSize        = 4;
1627         const size_t bufferSize         = offset + (elementCount - 1) * stride + elementSize;
1628
1629         char* data = new char[bufferSize];
1630         char* writePtr = data + offset;
1631
1632         deRandom rnd;
1633         deRandom_init(&rnd, seed);
1634
1635         for (int vertexNdx = 0; vertexNdx < elementCount; vertexNdx++)
1636         {
1637                 const deUint32 x                        = deRandom_getUint32(&rnd) % limit10;
1638                 const deUint32 y                        = deRandom_getUint32(&rnd) % limit10;
1639                 const deUint32 z                        = deRandom_getUint32(&rnd) % limit10;
1640                 const deUint32 w                        = deRandom_getUint32(&rnd) % limit2;
1641                 const deUint32 packedValue      = (w << 30) | (z << 20) | (y << 10) | (x);
1642
1643                 alignmentSafeAssignment(writePtr, packedValue);
1644                 writePtr += stride;
1645         }
1646
1647         return data;
1648 }
1649
1650 char* RandomArrayGenerator::generateIndices (int seed, int elementCount, DrawTestSpec::IndexType type, int offset, int min, int max, int indexBase)
1651 {
1652         char* data = DE_NULL;
1653
1654         switch (type)
1655         {
1656                 case DrawTestSpec::INDEXTYPE_BYTE:
1657                         data = createIndices<deUint8>(seed, elementCount, offset, min, max, indexBase);
1658                         break;
1659
1660                 case DrawTestSpec::INDEXTYPE_SHORT:
1661                         data = createIndices<deUint16>(seed, elementCount, offset, min, max, indexBase);
1662                         break;
1663
1664                 case DrawTestSpec::INDEXTYPE_INT:
1665                         data = createIndices<deUint32>(seed, elementCount, offset, min, max, indexBase);
1666                         break;
1667
1668                 default:
1669                         DE_ASSERT(false);
1670                         break;
1671         }
1672
1673         return data;
1674 }
1675
1676 template<typename T>
1677 char* RandomArrayGenerator::createIndices (int seed, int elementCount, int offset, int min, int max, int indexBase)
1678 {
1679         const size_t elementSize        = sizeof(T);
1680         const size_t bufferSize         = offset + elementCount * elementSize;
1681
1682         char* data = new char[bufferSize];
1683         char* writePtr = data + offset;
1684
1685         deUint32 oldNdx1 = deUint32(-1);
1686         deUint32 oldNdx2 = deUint32(-1);
1687
1688         deRandom rnd;
1689         deRandom_init(&rnd, seed);
1690
1691         DE_ASSERT(indexBase >= 0); // watch for underflows
1692
1693         if (min < 0 || (size_t)min > std::numeric_limits<T>::max() ||
1694                 max < 0 || (size_t)max > std::numeric_limits<T>::max() ||
1695                 min > max)
1696                 DE_FATAL("Invalid range");
1697
1698         for (int elementNdx = 0; elementNdx < elementCount; ++elementNdx)
1699         {
1700                 deUint32 ndx = getRandom(rnd, GLValue::Uint::create(min), GLValue::Uint::create(max)).getValue();
1701
1702                 // Try not to generate same index as any of previous two. This prevents
1703                 // generation of degenerate triangles and lines. If [min, max] is too
1704                 // small this cannot be guaranteed.
1705
1706                 if (ndx == oldNdx1)                     ++ndx;
1707                 if (ndx > (deUint32)max)        ndx = min;
1708                 if (ndx == oldNdx2)                     ++ndx;
1709                 if (ndx > (deUint32)max)        ndx = min;
1710                 if (ndx == oldNdx1)                     ++ndx;
1711                 if (ndx > (deUint32)max)        ndx = min;
1712
1713                 oldNdx2 = oldNdx1;
1714                 oldNdx1 = ndx;
1715
1716                 ndx += indexBase;
1717
1718                 alignmentSafeAssignment<T>(writePtr + elementSize * elementNdx, T(ndx));
1719         }
1720
1721         return data;
1722 }
1723
1724 rr::GenericVec4 RandomArrayGenerator::generateAttributeValue (int seed, DrawTestSpec::InputType type)
1725 {
1726         de::Random random(seed);
1727
1728         switch (type)
1729         {
1730                 case DrawTestSpec::INPUTTYPE_FLOAT:
1731                         return rr::GenericVec4(generateRandomVec4(random));
1732
1733                 case DrawTestSpec::INPUTTYPE_INT:
1734                         return rr::GenericVec4(generateRandomIVec4(random));
1735
1736                 case DrawTestSpec::INPUTTYPE_UNSIGNED_INT:
1737                         return rr::GenericVec4(generateRandomUVec4(random));
1738
1739                 default:
1740                         DE_ASSERT(false);
1741                         return rr::GenericVec4(tcu::Vec4(1, 1, 1, 1));
1742         }
1743 }
1744
1745 } // anonymous
1746
1747 // AttributePack
1748
1749 class AttributePack
1750 {
1751 public:
1752
1753                                                                 AttributePack           (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, sglr::Context& drawContext, const tcu::UVec2& screenSize, bool useVao, bool logEnabled);
1754                                                                 ~AttributePack          (void);
1755
1756         AttributeArray*                         getArray                        (int i);
1757         int                                                     getArrayCount           (void);
1758
1759         void                                            newArray                        (DrawTestSpec::Storage storage);
1760         void                                            clearArrays                     (void);
1761         void                                            updateProgram           (void);
1762
1763         void                                            render                          (DrawTestSpec::Primitive primitive, DrawTestSpec::DrawMethod drawMethod, int firstVertex, int vertexCount, DrawTestSpec::IndexType indexType, const void* indexOffset, int rangeStart, int rangeEnd, int instanceCount, int indirectOffset, int baseVertex, float coordScale, float colorScale, AttributeArray* indexArray);
1764
1765         const tcu::Surface&                     getSurface                      (void) const { return m_screen; }
1766 private:
1767         tcu::TestContext&                       m_testCtx;
1768         glu::RenderContext&                     m_renderCtx;
1769         sglr::Context&                          m_ctx;
1770
1771         std::vector<AttributeArray*>m_arrays;
1772         sglr::ShaderProgram*            m_program;
1773         tcu::Surface                            m_screen;
1774         const bool                                      m_useVao;
1775         const bool                                      m_logEnabled;
1776         deUint32                                        m_programID;
1777         deUint32                                        m_vaoID;
1778 };
1779
1780 AttributePack::AttributePack (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, sglr::Context& drawContext, const tcu::UVec2& screenSize, bool useVao, bool logEnabled)
1781         : m_testCtx             (testCtx)
1782         , m_renderCtx   (renderCtx)
1783         , m_ctx                 (drawContext)
1784         , m_program             (DE_NULL)
1785         , m_screen              (screenSize.x(), screenSize.y())
1786         , m_useVao              (useVao)
1787         , m_logEnabled  (logEnabled)
1788         , m_programID   (0)
1789         , m_vaoID               (0)
1790 {
1791         if (m_useVao)
1792                 m_ctx.genVertexArrays(1, &m_vaoID);
1793 }
1794
1795 AttributePack::~AttributePack (void)
1796 {
1797         clearArrays();
1798
1799         if (m_programID)
1800                 m_ctx.deleteProgram(m_programID);
1801
1802         if (m_program)
1803                 delete m_program;
1804
1805         if (m_useVao)
1806                 m_ctx.deleteVertexArrays(1, &m_vaoID);
1807 }
1808
1809 AttributeArray* AttributePack::getArray (int i)
1810 {
1811         return m_arrays.at(i);
1812 }
1813
1814 int AttributePack::getArrayCount (void)
1815 {
1816         return (int)m_arrays.size();
1817 }
1818
1819 void AttributePack::newArray (DrawTestSpec::Storage storage)
1820 {
1821         m_arrays.push_back(new AttributeArray(storage, m_ctx));
1822 }
1823
1824 void AttributePack::clearArrays (void)
1825 {
1826         for (std::vector<AttributeArray*>::iterator itr = m_arrays.begin(); itr != m_arrays.end(); itr++)
1827                 delete *itr;
1828         m_arrays.clear();
1829 }
1830
1831 void AttributePack::updateProgram (void)
1832 {
1833         if (m_programID)
1834                 m_ctx.deleteProgram(m_programID);
1835         if (m_program)
1836                 delete m_program;
1837
1838         m_program = new DrawTestShaderProgram(m_renderCtx, m_arrays);
1839         m_programID = m_ctx.createProgram(m_program);
1840 }
1841
1842 void AttributePack::render (DrawTestSpec::Primitive primitive, DrawTestSpec::DrawMethod drawMethod, int firstVertex, int vertexCount, DrawTestSpec::IndexType indexType, const void* indexOffset, int rangeStart, int rangeEnd, int instanceCount, int indirectOffset, int baseVertex, float coordScale, float colorScale, AttributeArray* indexArray)
1843 {
1844         DE_ASSERT(m_program != DE_NULL);
1845         DE_ASSERT(m_programID != 0);
1846
1847         m_ctx.viewport(0, 0, m_screen.getWidth(), m_screen.getHeight());
1848         m_ctx.clearColor(0.0, 0.0, 0.0, 1.0);
1849         m_ctx.clear(GL_COLOR_BUFFER_BIT);
1850
1851         m_ctx.useProgram(m_programID);
1852         GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glUseProgram()");
1853
1854         m_ctx.uniform1f(m_ctx.getUniformLocation(m_programID, "u_coordScale"), coordScale);
1855         m_ctx.uniform1f(m_ctx.getUniformLocation(m_programID, "u_colorScale"), colorScale);
1856
1857         if (m_useVao)
1858                 m_ctx.bindVertexArray(m_vaoID);
1859
1860         if (indexArray)
1861                 indexArray->bindIndexArray(DrawTestSpec::TARGET_ELEMENT_ARRAY);
1862
1863         for (int arrayNdx = 0; arrayNdx < (int)m_arrays.size(); arrayNdx++)
1864         {
1865                 std::stringstream attribName;
1866                 attribName << "a_" << arrayNdx;
1867
1868                 deUint32 loc = m_ctx.getAttribLocation(m_programID, attribName.str().c_str());
1869
1870                 if (m_arrays[arrayNdx]->isBound())
1871                 {
1872                         m_ctx.enableVertexAttribArray(loc);
1873                         GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glEnableVertexAttribArray()");
1874                 }
1875
1876                 m_arrays[arrayNdx]->bindAttribute(loc);
1877         }
1878
1879         if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWARRAYS)
1880         {
1881                 m_ctx.drawArrays(primitiveToGL(primitive), firstVertex, vertexCount);
1882                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawArrays()");
1883         }
1884         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWARRAYS_INSTANCED)
1885         {
1886                 m_ctx.drawArraysInstanced(primitiveToGL(primitive), firstVertex, vertexCount, instanceCount);
1887                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawArraysInstanced()");
1888         }
1889         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS)
1890         {
1891                 m_ctx.drawElements(primitiveToGL(primitive), vertexCount, indexTypeToGL(indexType), indexOffset);
1892                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawElements()");
1893         }
1894         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_RANGED)
1895         {
1896                 m_ctx.drawRangeElements(primitiveToGL(primitive), rangeStart, rangeEnd, vertexCount, indexTypeToGL(indexType), indexOffset);
1897                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawRangeElements()");
1898         }
1899         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_INSTANCED)
1900         {
1901                 m_ctx.drawElementsInstanced(primitiveToGL(primitive), vertexCount, indexTypeToGL(indexType), indexOffset, instanceCount);
1902                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawElementsInstanced()");
1903         }
1904         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWARRAYS_INDIRECT)
1905         {
1906                 struct DrawCommand
1907                 {
1908                         GLuint count;
1909                         GLuint primCount;
1910                         GLuint first;
1911                         GLuint reservedMustBeZero;
1912                 };
1913                 deUint8* buffer = new deUint8[sizeof(DrawCommand) + indirectOffset];
1914
1915                 {
1916                         DrawCommand command;
1917
1918                         command.count                           = vertexCount;
1919                         command.primCount                       = instanceCount;
1920                         command.first                           = firstVertex;
1921                         command.reservedMustBeZero      = 0;
1922
1923                         memcpy(buffer + indirectOffset, &command, sizeof(command));
1924
1925                         if (m_logEnabled)
1926                                 m_testCtx.getLog()
1927                                         << tcu::TestLog::Message
1928                                         << "DrawArraysIndirectCommand:\n"
1929                                         << "\tcount: " << command.count << "\n"
1930                                         << "\tprimCount: " << command.primCount << "\n"
1931                                         << "\tfirst: " << command.first << "\n"
1932                                         << "\treservedMustBeZero: " << command.reservedMustBeZero << "\n"
1933                                         << tcu::TestLog::EndMessage;
1934                 }
1935
1936                 GLuint indirectBuf = 0;
1937                 m_ctx.genBuffers(1, &indirectBuf);
1938                 m_ctx.bindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuf);
1939                 m_ctx.bufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawCommand) + indirectOffset, buffer, GL_STATIC_DRAW);
1940                 delete [] buffer;
1941
1942                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "Setup draw indirect buffer");
1943
1944                 m_ctx.drawArraysIndirect(primitiveToGL(primitive), (const deInt8*)DE_NULL + indirectOffset);
1945                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawArraysIndirect()");
1946
1947                 m_ctx.deleteBuffers(1, &indirectBuf);
1948         }
1949         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_INDIRECT)
1950         {
1951                 struct DrawCommand
1952                 {
1953                         GLuint count;
1954                         GLuint primCount;
1955                         GLuint firstIndex;
1956                         GLint  baseVertex;
1957                         GLuint reservedMustBeZero;
1958                 };
1959                 deUint8* buffer = new deUint8[sizeof(DrawCommand) + indirectOffset];
1960
1961                 {
1962                         DrawCommand command;
1963
1964                         // index offset must be converted to firstIndex by dividing with the index element size
1965                         DE_ASSERT(((const deUint8*)indexOffset - (const deUint8*)DE_NULL) % gls::DrawTestSpec::indexTypeSize(indexType) == 0); // \note This is checked in spec validation
1966
1967                         command.count                           = vertexCount;
1968                         command.primCount                       = instanceCount;
1969                         command.firstIndex                      = (glw::GLuint)(((const deUint8*)indexOffset - (const deUint8*)DE_NULL) / gls::DrawTestSpec::indexTypeSize(indexType));
1970                         command.baseVertex                      = baseVertex;
1971                         command.reservedMustBeZero      = 0;
1972
1973                         memcpy(buffer + indirectOffset, &command, sizeof(command));
1974
1975                         if (m_logEnabled)
1976                                 m_testCtx.getLog()
1977                                         << tcu::TestLog::Message
1978                                         << "DrawElementsIndirectCommand:\n"
1979                                         << "\tcount: " << command.count << "\n"
1980                                         << "\tprimCount: " << command.primCount << "\n"
1981                                         << "\tfirstIndex: " << command.firstIndex << "\n"
1982                                         << "\tbaseVertex: " << command.baseVertex << "\n"
1983                                         << "\treservedMustBeZero: " << command.reservedMustBeZero << "\n"
1984                                         << tcu::TestLog::EndMessage;
1985                 }
1986
1987                 GLuint indirectBuf = 0;
1988                 m_ctx.genBuffers(1, &indirectBuf);
1989                 m_ctx.bindBuffer(GL_DRAW_INDIRECT_BUFFER, indirectBuf);
1990                 m_ctx.bufferData(GL_DRAW_INDIRECT_BUFFER, sizeof(DrawCommand) + indirectOffset, buffer, GL_STATIC_DRAW);
1991                 delete [] buffer;
1992
1993                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "Setup draw indirect buffer");
1994
1995                 m_ctx.drawElementsIndirect(primitiveToGL(primitive), indexTypeToGL(indexType), (const deInt8*)DE_NULL + indirectOffset);
1996                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawArraysIndirect()");
1997
1998                 m_ctx.deleteBuffers(1, &indirectBuf);
1999         }
2000         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_BASEVERTEX)
2001         {
2002                 m_ctx.drawElementsBaseVertex(primitiveToGL(primitive), vertexCount, indexTypeToGL(indexType), indexOffset, baseVertex);
2003                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawElementsBaseVertex()");
2004         }
2005         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_INSTANCED_BASEVERTEX)
2006         {
2007                 m_ctx.drawElementsInstancedBaseVertex(primitiveToGL(primitive), vertexCount, indexTypeToGL(indexType), indexOffset, instanceCount, baseVertex);
2008                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawElementsInstancedBaseVertex()");
2009         }
2010         else if (drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_RANGED_BASEVERTEX)
2011         {
2012                 m_ctx.drawRangeElementsBaseVertex(primitiveToGL(primitive), rangeStart, rangeEnd, vertexCount, indexTypeToGL(indexType), indexOffset, baseVertex);
2013                 GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDrawRangeElementsBaseVertex()");
2014         }
2015         else
2016                 DE_ASSERT(DE_FALSE);
2017
2018         for (int arrayNdx = 0; arrayNdx < (int)m_arrays.size(); arrayNdx++)
2019         {
2020                 if (m_arrays[arrayNdx]->isBound())
2021                 {
2022                         std::stringstream attribName;
2023                         attribName << "a_" << arrayNdx;
2024
2025                         deUint32 loc = m_ctx.getAttribLocation(m_programID, attribName.str().c_str());
2026
2027                         m_ctx.disableVertexAttribArray(loc);
2028                         GLU_EXPECT_NO_ERROR(m_ctx.getError(), "glDisableVertexAttribArray()");
2029                 }
2030         }
2031
2032         if (m_useVao)
2033                 m_ctx.bindVertexArray(0);
2034
2035         m_ctx.useProgram(0);
2036         m_ctx.readPixels(m_screen, 0, 0, m_screen.getWidth(), m_screen.getHeight());
2037 }
2038
2039 // DrawTestSpec
2040
2041 DrawTestSpec::AttributeSpec     DrawTestSpec::AttributeSpec::createAttributeArray (InputType inputType, OutputType outputType, Storage storage, Usage usage, int componentCount, int offset, int stride, bool normalize, int instanceDivisor)
2042 {
2043         DrawTestSpec::AttributeSpec spec;
2044
2045         spec.inputType                  = inputType;
2046         spec.outputType                 = outputType;
2047         spec.storage                    = storage;
2048         spec.usage                              = usage;
2049         spec.componentCount             = componentCount;
2050         spec.offset                             = offset;
2051         spec.stride                             = stride;
2052         spec.normalize                  = normalize;
2053         spec.instanceDivisor    = instanceDivisor;
2054
2055         spec.useDefaultAttribute= false;
2056
2057         return spec;
2058 }
2059
2060 DrawTestSpec::AttributeSpec     DrawTestSpec::AttributeSpec::createDefaultAttribute (InputType inputType, OutputType outputType, int componentCount)
2061 {
2062         DE_ASSERT(inputType == INPUTTYPE_INT || inputType == INPUTTYPE_UNSIGNED_INT || inputType == INPUTTYPE_FLOAT);
2063         DE_ASSERT(inputType == INPUTTYPE_FLOAT || componentCount == 4);
2064
2065         DrawTestSpec::AttributeSpec spec;
2066
2067         spec.inputType                          = inputType;
2068         spec.outputType                         = outputType;
2069         spec.storage                            = DrawTestSpec::STORAGE_LAST;
2070         spec.usage                                      = DrawTestSpec::USAGE_LAST;
2071         spec.componentCount                     = componentCount;
2072         spec.offset                                     = 0;
2073         spec.stride                                     = 0;
2074         spec.normalize                          = 0;
2075         spec.instanceDivisor            = 0;
2076
2077         spec.useDefaultAttribute        = true;
2078
2079         return spec;
2080 }
2081
2082 DrawTestSpec::AttributeSpec::AttributeSpec (void)
2083 {
2084         inputType                                       = DrawTestSpec::INPUTTYPE_LAST;
2085         outputType                                      = DrawTestSpec::OUTPUTTYPE_LAST;
2086         storage                                         = DrawTestSpec::STORAGE_LAST;
2087         usage                                           = DrawTestSpec::USAGE_LAST;
2088         componentCount                          = 0;
2089         offset                                          = 0;
2090         stride                                          = 0;
2091         normalize                                       = false;
2092         instanceDivisor                         = 0;
2093         useDefaultAttribute                     = false;
2094         additionalPositionAttribute = false;
2095         bgraComponentOrder                      = false;
2096 }
2097
2098 int DrawTestSpec::AttributeSpec::hash (void) const
2099 {
2100         if (useDefaultAttribute)
2101         {
2102                 return 1 * int(inputType) + 7 * int(outputType) + 13 * componentCount;
2103         }
2104         else
2105         {
2106                 return 1 * int(inputType) + 2 * int(outputType) + 3 * int(storage) + 5 * int(usage) + 7 * componentCount + 11 * offset + 13 * stride + 17 * (normalize ? 0 : 1) + 19 * instanceDivisor;
2107         }
2108 }
2109
2110 bool DrawTestSpec::AttributeSpec::valid (glu::ApiType ctxType) const
2111 {
2112         const bool inputTypeFloat                               = inputType == DrawTestSpec::INPUTTYPE_FLOAT || inputType  == DrawTestSpec::INPUTTYPE_FIXED || inputType == DrawTestSpec::INPUTTYPE_HALF;
2113         const bool inputTypeUnsignedInteger             = inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE || inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT || inputType  == DrawTestSpec::INPUTTYPE_UNSIGNED_INT || inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10;
2114         const bool inputTypeSignedInteger               = inputType == DrawTestSpec::INPUTTYPE_BYTE  || inputType == DrawTestSpec::INPUTTYPE_SHORT || inputType == DrawTestSpec::INPUTTYPE_INT || inputType == DrawTestSpec::INPUTTYPE_INT_2_10_10_10;
2115         const bool inputTypePacked                              = inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || inputType == DrawTestSpec::INPUTTYPE_INT_2_10_10_10;
2116
2117         const bool outputTypeFloat                              = outputType == DrawTestSpec::OUTPUTTYPE_FLOAT || outputType == DrawTestSpec::OUTPUTTYPE_VEC2  || outputType == DrawTestSpec::OUTPUTTYPE_VEC3  || outputType == DrawTestSpec::OUTPUTTYPE_VEC4;
2118         const bool outputTypeSignedInteger              = outputType == DrawTestSpec::OUTPUTTYPE_INT   || outputType == DrawTestSpec::OUTPUTTYPE_IVEC2 || outputType == DrawTestSpec::OUTPUTTYPE_IVEC3 || outputType == DrawTestSpec::OUTPUTTYPE_IVEC4;
2119         const bool outputTypeUnsignedInteger    = outputType == DrawTestSpec::OUTPUTTYPE_UINT  || outputType == DrawTestSpec::OUTPUTTYPE_UVEC2 || outputType == DrawTestSpec::OUTPUTTYPE_UVEC3 || outputType == DrawTestSpec::OUTPUTTYPE_UVEC4;
2120
2121         if (useDefaultAttribute)
2122         {
2123                 if (inputType != DrawTestSpec::INPUTTYPE_INT && inputType != DrawTestSpec::INPUTTYPE_UNSIGNED_INT && inputType != DrawTestSpec::INPUTTYPE_FLOAT)
2124                         return false;
2125
2126                 if (inputType != DrawTestSpec::INPUTTYPE_FLOAT && componentCount != 4)
2127                         return false;
2128
2129                 // no casting allowed (undefined results)
2130                 if (inputType == DrawTestSpec::INPUTTYPE_INT && !outputTypeSignedInteger)
2131                         return false;
2132                 if (inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_INT && !outputTypeUnsignedInteger)
2133                         return false;
2134         }
2135
2136         if (inputTypePacked && componentCount != 4)
2137                 return false;
2138
2139         // Invalid conversions:
2140
2141         // float -> [u]int
2142         if (inputTypeFloat && !outputTypeFloat)
2143                 return false;
2144
2145         // uint -> int          (undefined results)
2146         if (inputTypeUnsignedInteger && outputTypeSignedInteger)
2147                 return false;
2148
2149         // int -> uint          (undefined results)
2150         if (inputTypeSignedInteger && outputTypeUnsignedInteger)
2151                 return false;
2152
2153         // packed -> non-float (packed formats are converted to floats)
2154         if (inputTypePacked && !outputTypeFloat)
2155                 return false;
2156
2157         // Invalid normalize. Normalize is only valid if output type is float
2158         if (normalize && !outputTypeFloat)
2159                 return false;
2160
2161         // Allow reverse order (GL_BGRA) only for packed and 4-component ubyte
2162         if (bgraComponentOrder && componentCount != 4)
2163                 return false;
2164         if (bgraComponentOrder && inputType != DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10 && inputType != DrawTestSpec::INPUTTYPE_INT_2_10_10_10 && inputType != DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE)
2165                 return false;
2166         if (bgraComponentOrder && normalize != true)
2167                 return false;
2168
2169         // GLES2 limits
2170         if (ctxType == glu::ApiType::es(2,0))
2171         {
2172                 if (inputType != DrawTestSpec::INPUTTYPE_FLOAT && inputType != DrawTestSpec::INPUTTYPE_FIXED &&
2173                         inputType != DrawTestSpec::INPUTTYPE_BYTE  && inputType != DrawTestSpec::INPUTTYPE_UNSIGNED_BYTE &&
2174                         inputType != DrawTestSpec::INPUTTYPE_SHORT && inputType != DrawTestSpec::INPUTTYPE_UNSIGNED_SHORT)
2175                         return false;
2176
2177                 if (!outputTypeFloat)
2178                         return false;
2179
2180                 if (bgraComponentOrder)
2181                         return false;
2182         }
2183
2184         // GLES3 limits
2185         if (ctxType.getProfile() == glu::PROFILE_ES && ctxType.getMajorVersion() == 3)
2186         {
2187                 if (bgraComponentOrder)
2188                         return false;
2189         }
2190
2191         // No user pointers in GL core
2192         if (ctxType.getProfile() == glu::PROFILE_CORE)
2193         {
2194                 if (!useDefaultAttribute && storage == DrawTestSpec::STORAGE_USER)
2195                         return false;
2196         }
2197
2198         return true;
2199 }
2200
2201 bool DrawTestSpec::AttributeSpec::isBufferAligned (void) const
2202 {
2203         const bool inputTypePacked = inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || inputType == DrawTestSpec::INPUTTYPE_INT_2_10_10_10;
2204
2205         // Buffer alignment, offset is a multiple of underlying data type size?
2206         if (storage == STORAGE_BUFFER)
2207         {
2208                 int dataTypeSize = gls::DrawTestSpec::inputTypeSize(inputType);
2209                 if (inputTypePacked)
2210                         dataTypeSize = 4;
2211
2212                 if (offset % dataTypeSize != 0)
2213                         return false;
2214         }
2215
2216         return true;
2217 }
2218
2219 bool DrawTestSpec::AttributeSpec::isBufferStrideAligned (void) const
2220 {
2221         const bool inputTypePacked = inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10 || inputType == DrawTestSpec::INPUTTYPE_INT_2_10_10_10;
2222
2223         // Buffer alignment, offset is a multiple of underlying data type size?
2224         if (storage == STORAGE_BUFFER)
2225         {
2226                 int dataTypeSize = gls::DrawTestSpec::inputTypeSize(inputType);
2227                 if (inputTypePacked)
2228                         dataTypeSize = 4;
2229
2230                 if (stride % dataTypeSize != 0)
2231                         return false;
2232         }
2233
2234         return true;
2235 }
2236
2237 std::string DrawTestSpec::targetToString(Target target)
2238 {
2239         static const char* targets[] =
2240         {
2241                 "element_array",        // TARGET_ELEMENT_ARRAY = 0,
2242                 "array"                         // TARGET_ARRAY,
2243         };
2244
2245         return de::getSizedArrayElement<DrawTestSpec::TARGET_LAST>(targets, (int)target);
2246 }
2247
2248 std::string DrawTestSpec::inputTypeToString(InputType type)
2249 {
2250         static const char* types[] =
2251         {
2252                 "float",                        // INPUTTYPE_FLOAT = 0,
2253                 "fixed",                        // INPUTTYPE_FIXED,
2254                 "double",                       // INPUTTYPE_DOUBLE
2255
2256                 "byte",                         // INPUTTYPE_BYTE,
2257                 "short",                        // INPUTTYPE_SHORT,
2258
2259                 "unsigned_byte",        // INPUTTYPE_UNSIGNED_BYTE,
2260                 "unsigned_short",       // INPUTTYPE_UNSIGNED_SHORT,
2261
2262                 "int",                                          // INPUTTYPE_INT,
2263                 "unsigned_int",                         // INPUTTYPE_UNSIGNED_INT,
2264                 "half",                                         // INPUTTYPE_HALF,
2265                 "unsigned_int2_10_10_10",       // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
2266                 "int2_10_10_10"                         // INPUTTYPE_INT_2_10_10_10,
2267         };
2268
2269         return de::getSizedArrayElement<DrawTestSpec::INPUTTYPE_LAST>(types, (int)type);
2270 }
2271
2272 std::string DrawTestSpec::outputTypeToString(OutputType type)
2273 {
2274         static const char* types[] =
2275         {
2276                 "float",                // OUTPUTTYPE_FLOAT = 0,
2277                 "vec2",                 // OUTPUTTYPE_VEC2,
2278                 "vec3",                 // OUTPUTTYPE_VEC3,
2279                 "vec4",                 // OUTPUTTYPE_VEC4,
2280
2281                 "int",                  // OUTPUTTYPE_INT,
2282                 "uint",                 // OUTPUTTYPE_UINT,
2283
2284                 "ivec2",                // OUTPUTTYPE_IVEC2,
2285                 "ivec3",                // OUTPUTTYPE_IVEC3,
2286                 "ivec4",                // OUTPUTTYPE_IVEC4,
2287
2288                 "uvec2",                // OUTPUTTYPE_UVEC2,
2289                 "uvec3",                // OUTPUTTYPE_UVEC3,
2290                 "uvec4",                // OUTPUTTYPE_UVEC4,
2291         };
2292
2293         return de::getSizedArrayElement<DrawTestSpec::OUTPUTTYPE_LAST>(types, (int)type);
2294 }
2295
2296 std::string DrawTestSpec::usageTypeToString(Usage usage)
2297 {
2298         static const char* usages[] =
2299         {
2300                 "dynamic_draw", // USAGE_DYNAMIC_DRAW = 0,
2301                 "static_draw",  // USAGE_STATIC_DRAW,
2302                 "stream_draw",  // USAGE_STREAM_DRAW,
2303
2304                 "stream_read",  // USAGE_STREAM_READ,
2305                 "stream_copy",  // USAGE_STREAM_COPY,
2306
2307                 "static_read",  // USAGE_STATIC_READ,
2308                 "static_copy",  // USAGE_STATIC_COPY,
2309
2310                 "dynamic_read", // USAGE_DYNAMIC_READ,
2311                 "dynamic_copy", // USAGE_DYNAMIC_COPY,
2312         };
2313
2314         return de::getSizedArrayElement<DrawTestSpec::USAGE_LAST>(usages, (int)usage);
2315 }
2316
2317 std::string     DrawTestSpec::storageToString (Storage storage)
2318 {
2319         static const char* storages[] =
2320         {
2321                 "user_ptr",     // STORAGE_USER = 0,
2322                 "buffer"        // STORAGE_BUFFER,
2323         };
2324
2325         return de::getSizedArrayElement<DrawTestSpec::STORAGE_LAST>(storages, (int)storage);
2326 }
2327
2328 std::string DrawTestSpec::primitiveToString (Primitive primitive)
2329 {
2330         static const char* primitives[] =
2331         {
2332                 "points",                                       // PRIMITIVE_POINTS ,
2333                 "triangles",                            // PRIMITIVE_TRIANGLES,
2334                 "triangle_fan",                         // PRIMITIVE_TRIANGLE_FAN,
2335                 "triangle_strip",                       // PRIMITIVE_TRIANGLE_STRIP,
2336                 "lines",                                        // PRIMITIVE_LINES
2337                 "line_strip",                           // PRIMITIVE_LINE_STRIP
2338                 "line_loop",                            // PRIMITIVE_LINE_LOOP
2339                 "lines_adjacency",                      // PRIMITIVE_LINES_ADJACENCY
2340                 "line_strip_adjacency",         // PRIMITIVE_LINE_STRIP_ADJACENCY
2341                 "triangles_adjacency",          // PRIMITIVE_TRIANGLES_ADJACENCY
2342                 "triangle_strip_adjacency",     // PRIMITIVE_TRIANGLE_STRIP_ADJACENCY
2343         };
2344
2345         return de::getSizedArrayElement<DrawTestSpec::PRIMITIVE_LAST>(primitives, (int)primitive);
2346 }
2347
2348 std::string DrawTestSpec::indexTypeToString (IndexType type)
2349 {
2350         static const char* indexTypes[] =
2351         {
2352                 "byte",         // INDEXTYPE_BYTE = 0,
2353                 "short",        // INDEXTYPE_SHORT,
2354                 "int",          // INDEXTYPE_INT,
2355         };
2356
2357         return de::getSizedArrayElement<DrawTestSpec::INDEXTYPE_LAST>(indexTypes, (int)type);
2358 }
2359
2360 std::string DrawTestSpec::drawMethodToString (DrawTestSpec::DrawMethod method)
2361 {
2362         static const char* methods[] =
2363         {
2364                 "draw_arrays",                                                  //!< DRAWMETHOD_DRAWARRAYS
2365                 "draw_arrays_instanced",                                //!< DRAWMETHOD_DRAWARRAYS_INSTANCED
2366                 "draw_arrays_indirect",                                 //!< DRAWMETHOD_DRAWARRAYS_INDIRECT
2367                 "draw_elements",                                                //!< DRAWMETHOD_DRAWELEMENTS
2368                 "draw_range_elements",                                  //!< DRAWMETHOD_DRAWELEMENTS_RANGED
2369                 "draw_elements_instanced",                              //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED
2370                 "draw_elements_indirect",                               //!< DRAWMETHOD_DRAWELEMENTS_INDIRECT
2371                 "draw_elements_base_vertex",                    //!< DRAWMETHOD_DRAWELEMENTS_BASEVERTEX,
2372                 "draw_elements_instanced_base_vertex",  //!< DRAWMETHOD_DRAWELEMENTS_INSTANCED_BASEVERTEX,
2373                 "draw_range_elements_base_vertex",              //!< DRAWMETHOD_DRAWELEMENTS_RANGED_BASEVERTEX,
2374         };
2375
2376         return de::getSizedArrayElement<DrawTestSpec::DRAWMETHOD_LAST>(methods, (int)method);
2377 }
2378
2379 int DrawTestSpec::inputTypeSize (InputType type)
2380 {
2381         static const int size[] =
2382         {
2383                 (int)sizeof(float),                     // INPUTTYPE_FLOAT = 0,
2384                 (int)sizeof(deInt32),           // INPUTTYPE_FIXED,
2385                 (int)sizeof(double),            // INPUTTYPE_DOUBLE
2386
2387                 (int)sizeof(deInt8),            // INPUTTYPE_BYTE,
2388                 (int)sizeof(deInt16),           // INPUTTYPE_SHORT,
2389
2390                 (int)sizeof(deUint8),           // INPUTTYPE_UNSIGNED_BYTE,
2391                 (int)sizeof(deUint16),          // INPUTTYPE_UNSIGNED_SHORT,
2392
2393                 (int)sizeof(deInt32),           // INPUTTYPE_INT,
2394                 (int)sizeof(deUint32),          // INPUTTYPE_UNSIGNED_INT,
2395                 (int)sizeof(deFloat16),         // INPUTTYPE_HALF,
2396                 (int)sizeof(deUint32) / 4,      // INPUTTYPE_UNSIGNED_INT_2_10_10_10,
2397                 (int)sizeof(deUint32) / 4       // INPUTTYPE_INT_2_10_10_10,
2398         };
2399
2400         return de::getSizedArrayElement<DrawTestSpec::INPUTTYPE_LAST>(size, (int)type);
2401 }
2402
2403 int DrawTestSpec::indexTypeSize (IndexType type)
2404 {
2405         static const int size[] =
2406         {
2407                 sizeof(deUint8),        // INDEXTYPE_BYTE,
2408                 sizeof(deUint16),       // INDEXTYPE_SHORT,
2409                 sizeof(deUint32),       // INDEXTYPE_INT,
2410         };
2411
2412         return de::getSizedArrayElement<DrawTestSpec::INDEXTYPE_LAST>(size, (int)type);
2413 }
2414
2415 std::string DrawTestSpec::getName (void) const
2416 {
2417         const MethodInfo        methodInfo      = getMethodInfo(drawMethod);
2418         const bool                      hasFirst        = methodInfo.first;
2419         const bool                      instanced       = methodInfo.instanced;
2420         const bool                      ranged          = methodInfo.ranged;
2421         const bool                      indexed         = methodInfo.indexed;
2422
2423         std::stringstream name;
2424
2425         for (size_t ndx = 0; ndx < attribs.size(); ++ndx)
2426         {
2427                 const AttributeSpec& attrib = attribs[ndx];
2428
2429                 if (attribs.size() > 1)
2430                         name << "attrib" << ndx << "_";
2431
2432                 if (ndx == 0|| attrib.additionalPositionAttribute)
2433                         name << "pos_";
2434                 else
2435                         name << "col_";
2436
2437                 if (attrib.useDefaultAttribute)
2438                 {
2439                         name
2440                                 << "non_array_"
2441                                 << DrawTestSpec::inputTypeToString((DrawTestSpec::InputType)attrib.inputType) << "_"
2442                                 << attrib.componentCount << "_"
2443                                 << DrawTestSpec::outputTypeToString(attrib.outputType) << "_";
2444                 }
2445                 else
2446                 {
2447                         name
2448                                 << DrawTestSpec::storageToString(attrib.storage) << "_"
2449                                 << attrib.offset << "_"
2450                                 << attrib.stride << "_"
2451                                 << DrawTestSpec::inputTypeToString((DrawTestSpec::InputType)attrib.inputType);
2452                         if (attrib.inputType != DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10 && attrib.inputType != DrawTestSpec::INPUTTYPE_INT_2_10_10_10)
2453                                 name << attrib.componentCount;
2454                         name
2455                                 << "_"
2456                                 << (attrib.normalize ? "normalized_" : "")
2457                                 << DrawTestSpec::outputTypeToString(attrib.outputType) << "_"
2458                                 << DrawTestSpec::usageTypeToString(attrib.usage) << "_"
2459                                 << attrib.instanceDivisor << "_";
2460                 }
2461         }
2462
2463         if (indexed)
2464                 name
2465                         << "index_" << DrawTestSpec::indexTypeToString(indexType) << "_"
2466                         << DrawTestSpec::storageToString(indexStorage) << "_"
2467                         << "offset" << indexPointerOffset << "_";
2468         if (hasFirst)
2469                 name << "first" << first << "_";
2470         if (ranged)
2471                 name << "ranged_" << indexMin << "_" << indexMax << "_";
2472         if (instanced)
2473                 name << "instances" << instanceCount << "_";
2474
2475         switch (primitive)
2476         {
2477                 case DrawTestSpec::PRIMITIVE_POINTS:
2478                         name << "points_";
2479                         break;
2480                 case DrawTestSpec::PRIMITIVE_TRIANGLES:
2481                         name << "triangles_";
2482                         break;
2483                 case DrawTestSpec::PRIMITIVE_TRIANGLE_FAN:
2484                         name << "triangle_fan_";
2485                         break;
2486                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP:
2487                         name << "triangle_strip_";
2488                         break;
2489                 case DrawTestSpec::PRIMITIVE_LINES:
2490                         name << "lines_";
2491                         break;
2492                 case DrawTestSpec::PRIMITIVE_LINE_STRIP:
2493                         name << "line_strip_";
2494                         break;
2495                 case DrawTestSpec::PRIMITIVE_LINE_LOOP:
2496                         name << "line_loop_";
2497                         break;
2498                 case DrawTestSpec::PRIMITIVE_LINES_ADJACENCY:
2499                         name << "line_adjancency";
2500                         break;
2501                 case DrawTestSpec::PRIMITIVE_LINE_STRIP_ADJACENCY:
2502                         name << "line_strip_adjancency";
2503                         break;
2504                 case DrawTestSpec::PRIMITIVE_TRIANGLES_ADJACENCY:
2505                         name << "triangles_adjancency";
2506                         break;
2507                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP_ADJACENCY:
2508                         name << "triangle_strip_adjancency";
2509                         break;
2510                 default:
2511                         DE_ASSERT(false);
2512                         break;
2513         }
2514
2515         name << primitiveCount;
2516
2517         return name.str();
2518 }
2519
2520 std::string DrawTestSpec::getDesc (void) const
2521 {
2522         std::stringstream desc;
2523
2524         for (size_t ndx = 0; ndx < attribs.size(); ++ndx)
2525         {
2526                 const AttributeSpec& attrib = attribs[ndx];
2527
2528                 if (attrib.useDefaultAttribute)
2529                 {
2530                         desc
2531                                 << "Attribute " << ndx << ": default, " << ((ndx == 0|| attrib.additionalPositionAttribute) ? ("position ,") : ("color ,"))
2532                                 << "input datatype " << DrawTestSpec::inputTypeToString((DrawTestSpec::InputType)attrib.inputType) << ", "
2533                                 << "input component count " << attrib.componentCount << ", "
2534                                 << "used as " << DrawTestSpec::outputTypeToString(attrib.outputType) << ", ";
2535                 }
2536                 else
2537                 {
2538                         desc
2539                                 << "Attribute " << ndx << ": " << ((ndx == 0|| attrib.additionalPositionAttribute) ? ("position ,") : ("color ,"))
2540                                 << "Storage in " << DrawTestSpec::storageToString(attrib.storage) << ", "
2541                                 << "stride " << attrib.stride << ", "
2542                                 << "input datatype " << DrawTestSpec::inputTypeToString((DrawTestSpec::InputType)attrib.inputType) << ", "
2543                                 << "input component count " << attrib.componentCount << ", "
2544                                 << (attrib.normalize ? "normalized, " : "")
2545                                 << "used as " << DrawTestSpec::outputTypeToString(attrib.outputType) << ", "
2546                                 << "instance divisor " << attrib.instanceDivisor << ", ";
2547                 }
2548         }
2549
2550         if (drawMethod == DRAWMETHOD_DRAWARRAYS)
2551         {
2552                 desc
2553                         << "drawArrays(), "
2554                         << "first " << first << ", ";
2555         }
2556         else if (drawMethod == DRAWMETHOD_DRAWARRAYS_INSTANCED)
2557         {
2558                 desc
2559                         << "drawArraysInstanced(), "
2560                         << "first " << first << ", "
2561                         << "instance count " << instanceCount << ", ";
2562         }
2563         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS)
2564         {
2565                 desc
2566                         << "drawElements(), "
2567                         << "index type " << DrawTestSpec::indexTypeToString(indexType) << ", "
2568                         << "index storage in " << DrawTestSpec::storageToString(indexStorage) << ", "
2569                         << "index offset " << indexPointerOffset << ", ";
2570         }
2571         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_RANGED)
2572         {
2573                 desc
2574                         << "drawElementsRanged(), "
2575                         << "index type " << DrawTestSpec::indexTypeToString(indexType) << ", "
2576                         << "index storage in " << DrawTestSpec::storageToString(indexStorage) << ", "
2577                         << "index offset " << indexPointerOffset << ", "
2578                         << "range start " << indexMin << ", "
2579                         << "range end " << indexMax << ", ";
2580         }
2581         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_INSTANCED)
2582         {
2583                 desc
2584                         << "drawElementsInstanced(), "
2585                         << "index type " << DrawTestSpec::indexTypeToString(indexType) << ", "
2586                         << "index storage in " << DrawTestSpec::storageToString(indexStorage) << ", "
2587                         << "index offset " << indexPointerOffset << ", "
2588                         << "instance count " << instanceCount << ", ";
2589         }
2590         else if (drawMethod == DRAWMETHOD_DRAWARRAYS_INDIRECT)
2591         {
2592                 desc
2593                         << "drawArraysIndirect(), "
2594                         << "first " << first << ", "
2595                         << "instance count " << instanceCount << ", "
2596                         << "indirect offset " << indirectOffset << ", ";
2597         }
2598         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_INDIRECT)
2599         {
2600                 desc
2601                         << "drawElementsIndirect(), "
2602                         << "index type " << DrawTestSpec::indexTypeToString(indexType) << ", "
2603                         << "index storage in " << DrawTestSpec::storageToString(indexStorage) << ", "
2604                         << "index offset " << indexPointerOffset << ", "
2605                         << "instance count " << instanceCount << ", "
2606                         << "indirect offset " << indirectOffset << ", "
2607                         << "base vertex " << baseVertex << ", ";
2608         }
2609         else
2610                 DE_ASSERT(DE_FALSE);
2611
2612         desc << primitiveCount;
2613
2614         switch (primitive)
2615         {
2616                 case DrawTestSpec::PRIMITIVE_POINTS:
2617                         desc << "points";
2618                         break;
2619                 case DrawTestSpec::PRIMITIVE_TRIANGLES:
2620                         desc << "triangles";
2621                         break;
2622                 case DrawTestSpec::PRIMITIVE_TRIANGLE_FAN:
2623                         desc << "triangles (fan)";
2624                         break;
2625                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP:
2626                         desc << "triangles (strip)";
2627                         break;
2628                 case DrawTestSpec::PRIMITIVE_LINES:
2629                         desc << "lines";
2630                         break;
2631                 case DrawTestSpec::PRIMITIVE_LINE_STRIP:
2632                         desc << "lines (strip)";
2633                         break;
2634                 case DrawTestSpec::PRIMITIVE_LINE_LOOP:
2635                         desc << "lines (loop)";
2636                         break;
2637                 case DrawTestSpec::PRIMITIVE_LINES_ADJACENCY:
2638                         desc << "lines (adjancency)";
2639                         break;
2640                 case DrawTestSpec::PRIMITIVE_LINE_STRIP_ADJACENCY:
2641                         desc << "lines (strip, adjancency)";
2642                         break;
2643                 case DrawTestSpec::PRIMITIVE_TRIANGLES_ADJACENCY:
2644                         desc << "triangles (adjancency)";
2645                         break;
2646                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP_ADJACENCY:
2647                         desc << "triangles (strip, adjancency)";
2648                         break;
2649                 default:
2650                         DE_ASSERT(false);
2651                         break;
2652         }
2653
2654         return desc.str();
2655 }
2656
2657 std::string DrawTestSpec::getMultilineDesc (void) const
2658 {
2659         std::stringstream desc;
2660
2661         for (size_t ndx = 0; ndx < attribs.size(); ++ndx)
2662         {
2663                 const AttributeSpec& attrib = attribs[ndx];
2664
2665                 if (attrib.useDefaultAttribute)
2666                 {
2667                         desc
2668                                 << "Attribute " << ndx << ": default, " << ((ndx == 0|| attrib.additionalPositionAttribute) ? ("position\n") : ("color\n"))
2669                                 << "\tinput datatype " << DrawTestSpec::inputTypeToString((DrawTestSpec::InputType)attrib.inputType) << "\n"
2670                                 << "\tinput component count " << attrib.componentCount << "\n"
2671                                 << "\tused as " << DrawTestSpec::outputTypeToString(attrib.outputType) << "\n";
2672                 }
2673                 else
2674                 {
2675                         desc
2676                                 << "Attribute " << ndx << ": " << ((ndx == 0|| attrib.additionalPositionAttribute) ? ("position\n") : ("color\n"))
2677                                 << "\tStorage in " << DrawTestSpec::storageToString(attrib.storage) << "\n"
2678                                 << "\tstride " << attrib.stride << "\n"
2679                                 << "\tinput datatype " << DrawTestSpec::inputTypeToString((DrawTestSpec::InputType)attrib.inputType) << "\n"
2680                                 << "\tinput component count " << attrib.componentCount << "\n"
2681                                 << (attrib.normalize ? "\tnormalized\n" : "")
2682                                 << "\tused as " << DrawTestSpec::outputTypeToString(attrib.outputType) << "\n"
2683                                 << "\tinstance divisor " << attrib.instanceDivisor << "\n";
2684                 }
2685         }
2686
2687         if (drawMethod == DRAWMETHOD_DRAWARRAYS)
2688         {
2689                 desc
2690                         << "drawArrays()\n"
2691                         << "\tfirst " << first << "\n";
2692         }
2693         else if (drawMethod == DRAWMETHOD_DRAWARRAYS_INSTANCED)
2694         {
2695                 desc
2696                         << "drawArraysInstanced()\n"
2697                         << "\tfirst " << first << "\n"
2698                         << "\tinstance count " << instanceCount << "\n";
2699         }
2700         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS)
2701         {
2702                 desc
2703                         << "drawElements()\n"
2704                         << "\tindex type " << DrawTestSpec::indexTypeToString(indexType) << "\n"
2705                         << "\tindex storage in " << DrawTestSpec::storageToString(indexStorage) << "\n"
2706                         << "\tindex offset " << indexPointerOffset << "\n";
2707         }
2708         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_RANGED)
2709         {
2710                 desc
2711                         << "drawElementsRanged()\n"
2712                         << "\tindex type " << DrawTestSpec::indexTypeToString(indexType) << "\n"
2713                         << "\tindex storage in " << DrawTestSpec::storageToString(indexStorage) << "\n"
2714                         << "\tindex offset " << indexPointerOffset << "\n"
2715                         << "\trange start " << indexMin << "\n"
2716                         << "\trange end " << indexMax << "\n";
2717         }
2718         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_INSTANCED)
2719         {
2720                 desc
2721                         << "drawElementsInstanced()\n"
2722                         << "\tindex type " << DrawTestSpec::indexTypeToString(indexType) << "\n"
2723                         << "\tindex storage in " << DrawTestSpec::storageToString(indexStorage) << "\n"
2724                         << "\tindex offset " << indexPointerOffset << "\n"
2725                         << "\tinstance count " << instanceCount << "\n";
2726         }
2727         else if (drawMethod == DRAWMETHOD_DRAWARRAYS_INDIRECT)
2728         {
2729                 desc
2730                         << "drawArraysIndirect()\n"
2731                         << "\tfirst " << first << "\n"
2732                         << "\tinstance count " << instanceCount << "\n"
2733                         << "\tindirect offset " << indirectOffset << "\n";
2734         }
2735         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_INDIRECT)
2736         {
2737                 desc
2738                         << "drawElementsIndirect()\n"
2739                         << "\tindex type " << DrawTestSpec::indexTypeToString(indexType) << "\n"
2740                         << "\tindex storage in " << DrawTestSpec::storageToString(indexStorage) << "\n"
2741                         << "\tindex offset " << indexPointerOffset << "\n"
2742                         << "\tinstance count " << instanceCount << "\n"
2743                         << "\tindirect offset " << indirectOffset << "\n"
2744                         << "\tbase vertex " << baseVertex << "\n";
2745         }
2746         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_BASEVERTEX)
2747         {
2748                 desc
2749                         << "drawElementsBaseVertex()\n"
2750                         << "\tindex type " << DrawTestSpec::indexTypeToString(indexType) << "\n"
2751                         << "\tindex storage in " << DrawTestSpec::storageToString(indexStorage) << "\n"
2752                         << "\tindex offset " << indexPointerOffset << "\n"
2753                         << "\tbase vertex " << baseVertex << "\n";
2754         }
2755         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_INSTANCED_BASEVERTEX)
2756         {
2757                 desc
2758                         << "drawElementsInstancedBaseVertex()\n"
2759                         << "\tindex type " << DrawTestSpec::indexTypeToString(indexType) << "\n"
2760                         << "\tindex storage in " << DrawTestSpec::storageToString(indexStorage) << "\n"
2761                         << "\tindex offset " << indexPointerOffset << "\n"
2762                         << "\tinstance count " << instanceCount << "\n"
2763                         << "\tbase vertex " << baseVertex << "\n";
2764         }
2765         else if (drawMethod == DRAWMETHOD_DRAWELEMENTS_RANGED_BASEVERTEX)
2766         {
2767                 desc
2768                         << "drawRangeElementsBaseVertex()\n"
2769                         << "\tindex type " << DrawTestSpec::indexTypeToString(indexType) << "\n"
2770                         << "\tindex storage in " << DrawTestSpec::storageToString(indexStorage) << "\n"
2771                         << "\tindex offset " << indexPointerOffset << "\n"
2772                         << "\tbase vertex " << baseVertex << "\n"
2773                         << "\trange start " << indexMin << "\n"
2774                         << "\trange end " << indexMax << "\n";
2775         }
2776         else
2777                 DE_ASSERT(DE_FALSE);
2778
2779         desc << "\t" << primitiveCount << " ";
2780
2781         switch (primitive)
2782         {
2783                 case DrawTestSpec::PRIMITIVE_POINTS:
2784                         desc << "points";
2785                         break;
2786                 case DrawTestSpec::PRIMITIVE_TRIANGLES:
2787                         desc << "triangles";
2788                         break;
2789                 case DrawTestSpec::PRIMITIVE_TRIANGLE_FAN:
2790                         desc << "triangles (fan)";
2791                         break;
2792                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP:
2793                         desc << "triangles (strip)";
2794                         break;
2795                 case DrawTestSpec::PRIMITIVE_LINES:
2796                         desc << "lines";
2797                         break;
2798                 case DrawTestSpec::PRIMITIVE_LINE_STRIP:
2799                         desc << "lines (strip)";
2800                         break;
2801                 case DrawTestSpec::PRIMITIVE_LINE_LOOP:
2802                         desc << "lines (loop)";
2803                         break;
2804                 case DrawTestSpec::PRIMITIVE_LINES_ADJACENCY:
2805                         desc << "lines (adjancency)";
2806                         break;
2807                 case DrawTestSpec::PRIMITIVE_LINE_STRIP_ADJACENCY:
2808                         desc << "lines (strip, adjancency)";
2809                         break;
2810                 case DrawTestSpec::PRIMITIVE_TRIANGLES_ADJACENCY:
2811                         desc << "triangles (adjancency)";
2812                         break;
2813                 case DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP_ADJACENCY:
2814                         desc << "triangles (strip, adjancency)";
2815                         break;
2816                 default:
2817                         DE_ASSERT(false);
2818                         break;
2819         }
2820
2821         desc << "\n";
2822
2823         return desc.str();
2824 }
2825
2826 DrawTestSpec::DrawTestSpec (void)
2827 {
2828         primitive                       = PRIMITIVE_LAST;
2829         primitiveCount          = 0;
2830         drawMethod                      = DRAWMETHOD_LAST;
2831         indexType                       = INDEXTYPE_LAST;
2832         indexPointerOffset      = 0;
2833         indexStorage            = STORAGE_LAST;
2834         first                           = 0;
2835         indexMin                        = 0;
2836         indexMax                        = 0;
2837         instanceCount           = 0;
2838         indirectOffset          = 0;
2839         baseVertex                      = 0;
2840 }
2841
2842 int DrawTestSpec::hash (void) const
2843 {
2844         // Use only drawmode-relevant values in "hashing" as the unrelevant values might not be set (causing non-deterministic behavior).
2845         const MethodInfo        methodInfo              = getMethodInfo(drawMethod);
2846         const bool                      arrayed                 = methodInfo.first;
2847         const bool                      instanced               = methodInfo.instanced;
2848         const bool                      ranged                  = methodInfo.ranged;
2849         const bool                      indexed                 = methodInfo.indexed;
2850         const bool                      indirect                = methodInfo.indirect;
2851         const bool                      hasBaseVtx              = methodInfo.baseVertex;
2852
2853         const int                       indexHash               = (!indexed)    ? (0) : (int(indexType) + 10 * indexPointerOffset + 100 * int(indexStorage));
2854         const int                       arrayHash               = (!arrayed)    ? (0) : (first);
2855         const int                       indexRangeHash  = (!ranged)             ? (0) : (indexMin + 10 * indexMax);
2856         const int                       instanceHash    = (!instanced)  ? (0) : (instanceCount);
2857         const int                       indirectHash    = (!indirect)   ? (0) : (indirectOffset);
2858         const int                       baseVtxHash             = (!hasBaseVtx) ? (0) : (baseVertex);
2859         const int                       basicHash               = int(primitive) + 10 * primitiveCount + 100 * int(drawMethod);
2860
2861         return indexHash + 3 * arrayHash + 5 * indexRangeHash + 7 * instanceHash + 13 * basicHash + 17 * (int)attribs.size() + 19 * primitiveCount + 23 * indirectHash + 27 * baseVtxHash;
2862 }
2863
2864 bool DrawTestSpec::valid (void) const
2865 {
2866         DE_ASSERT(apiType.getProfile() != glu::PROFILE_LAST);
2867         DE_ASSERT(primitive != PRIMITIVE_LAST);
2868         DE_ASSERT(drawMethod != DRAWMETHOD_LAST);
2869
2870         const MethodInfo methodInfo = getMethodInfo(drawMethod);
2871
2872         for (int ndx = 0; ndx < (int)attribs.size(); ++ndx)
2873                 if (!attribs[ndx].valid(apiType))
2874                         return false;
2875
2876         if (methodInfo.ranged)
2877         {
2878                 deUint32 maxIndexValue = 0;
2879                 if (indexType == INDEXTYPE_BYTE)
2880                         maxIndexValue = GLValue::getMaxValue(INPUTTYPE_UNSIGNED_BYTE).ub.getValue();
2881                 else if (indexType == INDEXTYPE_SHORT)
2882                         maxIndexValue = GLValue::getMaxValue(INPUTTYPE_UNSIGNED_SHORT).us.getValue();
2883                 else if (indexType == INDEXTYPE_INT)
2884                         maxIndexValue = GLValue::getMaxValue(INPUTTYPE_UNSIGNED_INT).ui.getValue();
2885                 else
2886                         DE_ASSERT(DE_FALSE);
2887
2888                 if (indexMin > indexMax)
2889                         return false;
2890                 if (indexMin < 0 || indexMax < 0)
2891                         return false;
2892                 if ((deUint32)indexMin > maxIndexValue || (deUint32)indexMax > maxIndexValue)
2893                         return false;
2894         }
2895
2896         if (methodInfo.first && first < 0)
2897                 return false;
2898
2899         // GLES2 limits
2900         if (apiType == glu::ApiType::es(2,0))
2901         {
2902                 if (drawMethod != gls::DrawTestSpec::DRAWMETHOD_DRAWARRAYS && drawMethod != gls::DrawTestSpec::DRAWMETHOD_DRAWELEMENTS)
2903                         return false;
2904                 if (drawMethod == gls::DrawTestSpec::DRAWMETHOD_DRAWELEMENTS && (indexType != INDEXTYPE_BYTE && indexType != INDEXTYPE_SHORT))
2905                         return false;
2906         }
2907
2908         // Indirect limitations
2909         if (methodInfo.indirect)
2910         {
2911                 // Indirect offset alignment
2912                 if (indirectOffset % 4 != 0)
2913                         return false;
2914
2915                 // All attribute arrays must be stored in a buffer
2916                 for (int ndx = 0; ndx < (int)attribs.size(); ++ndx)
2917                         if (!attribs[ndx].useDefaultAttribute && attribs[ndx].storage == gls::DrawTestSpec::STORAGE_USER)
2918                                 return false;
2919         }
2920         if (drawMethod == DRAWMETHOD_DRAWELEMENTS_INDIRECT)
2921         {
2922                 // index offset must be convertable to firstIndex
2923                 if (indexPointerOffset % gls::DrawTestSpec::indexTypeSize(indexType) != 0)
2924                         return false;
2925
2926                 // Indices must be in a buffer
2927                 if (indexStorage != STORAGE_BUFFER)
2928                         return false;
2929         }
2930
2931         // Do not allow user pointer in GL core
2932         if (apiType.getProfile() == glu::PROFILE_CORE)
2933         {
2934                 if (methodInfo.indexed && indexStorage == DrawTestSpec::STORAGE_USER)
2935                         return false;
2936         }
2937
2938         return true;
2939 }
2940
2941 DrawTestSpec::CompatibilityTestType DrawTestSpec::isCompatibilityTest (void) const
2942 {
2943         const MethodInfo methodInfo = getMethodInfo(drawMethod);
2944
2945         bool bufferAlignmentBad = false;
2946         bool strideAlignmentBad = false;
2947
2948         // Attribute buffer alignment
2949         for (int ndx = 0; ndx < (int)attribs.size(); ++ndx)
2950                 if (!attribs[ndx].isBufferAligned())
2951                         bufferAlignmentBad = true;
2952
2953         // Attribute stride alignment
2954         for (int ndx = 0; ndx < (int)attribs.size(); ++ndx)
2955                 if (!attribs[ndx].isBufferStrideAligned())
2956                         strideAlignmentBad = true;
2957
2958         // Index buffer alignment
2959         if (methodInfo.indexed)
2960         {
2961                 if (indexStorage == STORAGE_BUFFER)
2962                 {
2963                         int indexSize = 0;
2964                         if (indexType == INDEXTYPE_BYTE)
2965                                 indexSize = 1;
2966                         else if (indexType == INDEXTYPE_SHORT)
2967                                 indexSize = 2;
2968                         else if (indexType == INDEXTYPE_INT)
2969                                 indexSize = 4;
2970                         else
2971                                 DE_ASSERT(DE_FALSE);
2972
2973                         if (indexPointerOffset % indexSize != 0)
2974                                 bufferAlignmentBad = true;
2975                 }
2976         }
2977
2978         // \note combination bad alignment & stride is treated as bad offset
2979         if (bufferAlignmentBad)
2980                 return COMPATIBILITY_UNALIGNED_OFFSET;
2981         else if (strideAlignmentBad)
2982                 return COMPATIBILITY_UNALIGNED_STRIDE;
2983         else
2984                 return COMPATIBILITY_NONE;
2985 }
2986
2987 enum PrimitiveClass
2988 {
2989         PRIMITIVECLASS_POINT = 0,
2990         PRIMITIVECLASS_LINE,
2991         PRIMITIVECLASS_TRIANGLE,
2992
2993         PRIMITIVECLASS_LAST
2994 };
2995
2996 static PrimitiveClass getDrawPrimitiveClass (gls::DrawTestSpec::Primitive primitiveType)
2997 {
2998         switch (primitiveType)
2999         {
3000                 case gls::DrawTestSpec::PRIMITIVE_POINTS:
3001                         return PRIMITIVECLASS_POINT;
3002
3003                 case gls::DrawTestSpec::PRIMITIVE_LINES:
3004                 case gls::DrawTestSpec::PRIMITIVE_LINE_STRIP:
3005                 case gls::DrawTestSpec::PRIMITIVE_LINE_LOOP:
3006                 case gls::DrawTestSpec::PRIMITIVE_LINES_ADJACENCY:
3007                 case gls::DrawTestSpec::PRIMITIVE_LINE_STRIP_ADJACENCY:
3008                         return PRIMITIVECLASS_LINE;
3009
3010                 case gls::DrawTestSpec::PRIMITIVE_TRIANGLES:
3011                 case gls::DrawTestSpec::PRIMITIVE_TRIANGLE_FAN:
3012                 case gls::DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP:
3013                 case gls::DrawTestSpec::PRIMITIVE_TRIANGLES_ADJACENCY:
3014                 case gls::DrawTestSpec::PRIMITIVE_TRIANGLE_STRIP_ADJACENCY:
3015                         return PRIMITIVECLASS_TRIANGLE;
3016
3017                 default:
3018                         DE_ASSERT(false);
3019                         return PRIMITIVECLASS_LAST;
3020         }
3021 }
3022
3023 static bool containsLineCases (const std::vector<DrawTestSpec>& m_specs)
3024 {
3025         for (int ndx = 0; ndx < (int)m_specs.size(); ++ndx)
3026         {
3027                 if (getDrawPrimitiveClass(m_specs[ndx].primitive) == PRIMITIVECLASS_LINE)
3028                         return true;
3029         }
3030         return false;
3031 }
3032
3033 // DrawTest
3034
3035 DrawTest::DrawTest (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const DrawTestSpec& spec, const char* name, const char* desc)
3036         : TestCase                      (testCtx, name, desc)
3037         , m_renderCtx           (renderCtx)
3038         , m_contextInfo         (DE_NULL)
3039         , m_refBuffers          (DE_NULL)
3040         , m_refContext          (DE_NULL)
3041         , m_glesContext         (DE_NULL)
3042         , m_glArrayPack         (DE_NULL)
3043         , m_rrArrayPack         (DE_NULL)
3044         , m_maxDiffRed          (-1)
3045         , m_maxDiffGreen        (-1)
3046         , m_maxDiffBlue         (-1)
3047         , m_iteration           (0)
3048         , m_result                      ()      // \note no per-iteration result logging (only one iteration)
3049 {
3050         addIteration(spec);
3051 }
3052
3053 DrawTest::DrawTest (tcu::TestContext& testCtx, glu::RenderContext& renderCtx, const char* name, const char* desc)
3054         : TestCase                      (testCtx, name, desc)
3055         , m_renderCtx           (renderCtx)
3056         , m_contextInfo         (DE_NULL)
3057         , m_refBuffers          (DE_NULL)
3058         , m_refContext          (DE_NULL)
3059         , m_glesContext         (DE_NULL)
3060         , m_glArrayPack         (DE_NULL)
3061         , m_rrArrayPack         (DE_NULL)
3062         , m_maxDiffRed          (-1)
3063         , m_maxDiffGreen        (-1)
3064         , m_maxDiffBlue         (-1)
3065         , m_iteration           (0)
3066         , m_result                      (testCtx.getLog(), "Iteration result: ")
3067 {
3068 }
3069
3070 DrawTest::~DrawTest     (void)
3071 {
3072         deinit();
3073 }
3074
3075 void DrawTest::addIteration (const DrawTestSpec& spec, const char* description)
3076 {
3077         // Validate spec
3078         const bool validSpec = spec.valid();
3079         DE_ASSERT(validSpec);
3080
3081         if (!validSpec)
3082                 return;
3083
3084         // Check the context type is the same with other iterations
3085         if (!m_specs.empty())
3086         {
3087                 const bool validContext = m_specs[0].apiType == spec.apiType;
3088                 DE_ASSERT(validContext);
3089
3090                 if (!validContext)
3091                         return;
3092         }
3093
3094         m_specs.push_back(spec);
3095
3096         if (description)
3097                 m_iteration_descriptions.push_back(std::string(description));
3098         else
3099                 m_iteration_descriptions.push_back(std::string());
3100 }
3101
3102 void DrawTest::init (void)
3103 {
3104         DE_ASSERT(!m_specs.empty());
3105         DE_ASSERT(contextSupports(m_renderCtx.getType(), m_specs[0].apiType));
3106
3107         const int                                               renderTargetWidth       = de::min(MAX_RENDER_TARGET_SIZE, m_renderCtx.getRenderTarget().getWidth());
3108         const int                                               renderTargetHeight      = de::min(MAX_RENDER_TARGET_SIZE, m_renderCtx.getRenderTarget().getHeight());
3109
3110         // lines have significantly different rasterization in MSAA mode
3111         const bool                                              isLineCase                      = containsLineCases(m_specs);
3112         const bool                                              isMSAACase                      = m_renderCtx.getRenderTarget().getNumSamples() > 1;
3113         const int                                               renderTargetSamples     = (isMSAACase && isLineCase) ? (4) : (1);
3114
3115         sglr::ReferenceContextLimits    limits                          (m_renderCtx);
3116         bool                                                    useVao                          = false;
3117
3118         m_glesContext = new sglr::GLContext(m_renderCtx, m_testCtx.getLog(), sglr::GLCONTEXT_LOG_CALLS | sglr::GLCONTEXT_LOG_PROGRAMS, tcu::IVec4(0, 0, renderTargetWidth, renderTargetHeight));
3119
3120         if (m_renderCtx.getType().getAPI() == glu::ApiType::es(2,0) || m_renderCtx.getType().getAPI() == glu::ApiType::es(3,0))
3121                 useVao = false;
3122         else if (contextSupports(m_renderCtx.getType(), glu::ApiType::es(3,1)) || glu::isContextTypeGLCore(m_renderCtx.getType()))
3123                 useVao = true;
3124         else
3125                 DE_FATAL("Unknown context type");
3126
3127         m_refBuffers    = new sglr::ReferenceContextBuffers(m_renderCtx.getRenderTarget().getPixelFormat(), 0, 0, renderTargetWidth, renderTargetHeight, renderTargetSamples);
3128         m_refContext    = new sglr::ReferenceContext(limits, m_refBuffers->getColorbuffer(), m_refBuffers->getDepthbuffer(), m_refBuffers->getStencilbuffer());
3129
3130         m_glArrayPack   = new AttributePack(m_testCtx, m_renderCtx, *m_glesContext, tcu::UVec2(renderTargetWidth, renderTargetHeight), useVao, true);
3131         m_rrArrayPack   = new AttributePack(m_testCtx, m_renderCtx, *m_refContext,  tcu::UVec2(renderTargetWidth, renderTargetHeight), useVao, false);
3132
3133         m_maxDiffRed    = deCeilFloatToInt32(256.0f * (6.0f / (float)(1 << m_renderCtx.getRenderTarget().getPixelFormat().redBits)));
3134         m_maxDiffGreen  = deCeilFloatToInt32(256.0f * (6.0f / (float)(1 << m_renderCtx.getRenderTarget().getPixelFormat().greenBits)));
3135         m_maxDiffBlue   = deCeilFloatToInt32(256.0f * (6.0f / (float)(1 << m_renderCtx.getRenderTarget().getPixelFormat().blueBits)));
3136         m_contextInfo   = glu::ContextInfo::create(m_renderCtx);
3137 }
3138
3139 void DrawTest::deinit (void)
3140 {
3141         delete m_glArrayPack;
3142         delete m_rrArrayPack;
3143         delete m_refBuffers;
3144         delete m_refContext;
3145         delete m_glesContext;
3146         delete m_contextInfo;
3147
3148         m_glArrayPack   = DE_NULL;
3149         m_rrArrayPack   = DE_NULL;
3150         m_refBuffers    = DE_NULL;
3151         m_refContext    = DE_NULL;
3152         m_glesContext   = DE_NULL;
3153         m_contextInfo   = DE_NULL;
3154 }
3155
3156 DrawTest::IterateResult DrawTest::iterate (void)
3157 {
3158         const int                                       specNdx                 = (m_iteration / 2);
3159         const DrawTestSpec&                     spec                    = m_specs[specNdx];
3160
3161         if (spec.drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_BASEVERTEX ||
3162                 spec.drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_INSTANCED_BASEVERTEX ||
3163                 spec.drawMethod == DrawTestSpec::DRAWMETHOD_DRAWELEMENTS_RANGED_BASEVERTEX)
3164         {
3165                 const bool supportsES32 = contextSupports(m_renderCtx.getType(), glu::ApiType::es(3, 2));
3166                 TCU_CHECK_AND_THROW(NotSupportedError, supportsES32 || m_contextInfo->isExtensionSupported("GL_EXT_draw_elements_base_vertex"), "GL_EXT_draw_elements_base_vertex is not supported.");
3167         }
3168
3169         const bool                                      drawStep                = (m_iteration % 2) == 0;
3170         const bool                                      compareStep             = (m_iteration % 2) == 1;
3171         const IterateResult                     iterateResult   = ((size_t)m_iteration + 1 == m_specs.size()*2) ? (STOP) : (CONTINUE);
3172         const bool                                      updateProgram   = (m_iteration == 0) || (drawStep && !checkSpecsShaderCompatible(m_specs[specNdx], m_specs[specNdx-1])); // try to use the same shader in all iterations
3173         IterationLogSectionEmitter      sectionEmitter  (m_testCtx.getLog(), specNdx, m_specs.size(), m_iteration_descriptions[specNdx], drawStep && m_specs.size()!=1);
3174
3175         if (drawStep)
3176         {
3177                 const MethodInfo        methodInfo                              = getMethodInfo(spec.drawMethod);
3178                 const bool                      indexed                                 = methodInfo.indexed;
3179                 const bool                      instanced                               = methodInfo.instanced;
3180                 const bool                      ranged                                  = methodInfo.ranged;
3181                 const bool                      hasFirst                                = methodInfo.first;
3182                 const bool                      hasBaseVtx                              = methodInfo.baseVertex;
3183
3184                 const size_t            primitiveElementCount   = getElementCount(spec.primitive, spec.primitiveCount);                                         // !< elements to be drawn
3185                 const int                       indexMin                                = (ranged) ? (spec.indexMin) : (0);
3186                 const int                       firstAddition                   = (hasFirst) ? (spec.first) : (0);
3187                 const int                       baseVertexAddition              = (hasBaseVtx && spec.baseVertex > 0) ? ( spec.baseVertex) : (0);                       // spec.baseVertex > 0 => Create bigger attribute buffer
3188                 const int                       indexBase                               = (hasBaseVtx && spec.baseVertex < 0) ? (-spec.baseVertex) : (0);                       // spec.baseVertex < 0 => Create bigger indices
3189                 const size_t            elementCount                    = primitiveElementCount + indexMin + firstAddition + baseVertexAddition;        // !< elements in buffer (buffer should have at least primitiveElementCount ACCESSIBLE (index range, first) elements)
3190                 const int                       maxElementIndex                 = (int)primitiveElementCount + indexMin + firstAddition - 1;
3191                 const int                       indexMax                                = de::max(0, (ranged) ? (de::clamp<int>(spec.indexMax, 0, maxElementIndex)) : (maxElementIndex));
3192                 float                           coordScale                              = getCoordScale(spec);
3193                 float                           colorScale                              = getColorScale(spec);
3194
3195                 rr::GenericVec4         nullAttribValue;
3196
3197                 // Log info
3198                 m_testCtx.getLog() << TestLog::Message << spec.getMultilineDesc() << TestLog::EndMessage;
3199                 m_testCtx.getLog() << TestLog::Message << TestLog::EndMessage; // extra line for clarity
3200
3201                 // Data
3202
3203                 m_glArrayPack->clearArrays();
3204                 m_rrArrayPack->clearArrays();
3205
3206                 for (int attribNdx = 0; attribNdx < (int)spec.attribs.size(); attribNdx++)
3207                 {
3208                         DrawTestSpec::AttributeSpec attribSpec          = spec.attribs[attribNdx];
3209                         const bool                                      isPositionAttr  = (attribNdx == 0) || (attribSpec.additionalPositionAttribute);
3210
3211                         if (attribSpec.useDefaultAttribute)
3212                         {
3213                                 const int               seed            = 10 * attribSpec.hash() + 100 * spec.hash() + attribNdx;
3214                                 rr::GenericVec4 attribValue = RandomArrayGenerator::generateAttributeValue(seed, attribSpec.inputType);
3215
3216                                 m_glArrayPack->newArray(DrawTestSpec::STORAGE_USER);
3217                                 m_rrArrayPack->newArray(DrawTestSpec::STORAGE_USER);
3218
3219                                 m_glArrayPack->getArray(attribNdx)->setupArray(false, 0, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, false, 0, 0, attribValue, isPositionAttr, false);
3220                                 m_rrArrayPack->getArray(attribNdx)->setupArray(false, 0, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, false, 0, 0, attribValue, isPositionAttr, false);
3221                         }
3222                         else
3223                         {
3224                                 const int                                       seed                                    = attribSpec.hash() + 100 * spec.hash() + attribNdx;
3225                                 const size_t                            elementSize                             = attribSpec.componentCount * DrawTestSpec::inputTypeSize(attribSpec.inputType);
3226                                 const size_t                            stride                                  = (attribSpec.stride == 0) ? (elementSize) : (attribSpec.stride);
3227                                 const size_t                            evaluatedElementCount   = (instanced && attribSpec.instanceDivisor > 0) ? (spec.instanceCount / attribSpec.instanceDivisor + 1) : (elementCount);
3228                                 const size_t                            referencedElementCount  = (ranged) ? (de::max<size_t>(evaluatedElementCount, spec.indexMax + 1)) : (evaluatedElementCount);
3229                                 const size_t                            bufferSize                              = attribSpec.offset + stride * (referencedElementCount - 1) + elementSize;
3230                                 const char*                                     data                                    = RandomArrayGenerator::generateArray(seed, (int)referencedElementCount, attribSpec.componentCount, attribSpec.offset, (int)stride, attribSpec.inputType);
3231
3232                                 try
3233                                 {
3234                                         m_glArrayPack->newArray(attribSpec.storage);
3235                                         m_rrArrayPack->newArray(attribSpec.storage);
3236
3237                                         m_glArrayPack->getArray(attribNdx)->data(DrawTestSpec::TARGET_ARRAY, bufferSize, data, attribSpec.usage);
3238                                         m_rrArrayPack->getArray(attribNdx)->data(DrawTestSpec::TARGET_ARRAY, bufferSize, data, attribSpec.usage);
3239
3240                                         m_glArrayPack->getArray(attribNdx)->setupArray(true, attribSpec.offset, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, attribSpec.normalize, attribSpec.stride, attribSpec.instanceDivisor, nullAttribValue, isPositionAttr, attribSpec.bgraComponentOrder);
3241                                         m_rrArrayPack->getArray(attribNdx)->setupArray(true, attribSpec.offset, attribSpec.componentCount, attribSpec.inputType, attribSpec.outputType, attribSpec.normalize, attribSpec.stride, attribSpec.instanceDivisor, nullAttribValue, isPositionAttr, attribSpec.bgraComponentOrder);
3242
3243                                         delete [] data;
3244                                         data = NULL;
3245                                 }
3246                                 catch (...)
3247                                 {
3248                                         delete [] data;
3249                                         throw;
3250                                 }
3251                         }
3252                 }
3253
3254                 // Shader program
3255                 if (updateProgram)
3256                 {
3257                         m_glArrayPack->updateProgram();
3258                         m_rrArrayPack->updateProgram();
3259                 }
3260
3261                 // Draw
3262                 try
3263                 {
3264                         // indices
3265                         if (indexed)
3266                         {
3267                                 const int               seed                            = spec.hash();
3268                                 const size_t    indexElementSize        = DrawTestSpec::indexTypeSize(spec.indexType);
3269                                 const size_t    indexArraySize          = spec.indexPointerOffset + indexElementSize * elementCount;
3270                                 const char*             indexArray                      = RandomArrayGenerator::generateIndices(seed, (int)elementCount, spec.indexType, spec.indexPointerOffset, indexMin, indexMax, indexBase);
3271                                 const char*             indexPointerBase        = (spec.indexStorage == DrawTestSpec::STORAGE_USER) ? (indexArray) : ((char*)DE_NULL);
3272                                 const char*             indexPointer            = indexPointerBase + spec.indexPointerOffset;
3273
3274                                 de::UniquePtr<AttributeArray> glArray   (new AttributeArray(spec.indexStorage, *m_glesContext));
3275                                 de::UniquePtr<AttributeArray> rrArray   (new AttributeArray(spec.indexStorage, *m_refContext));
3276
3277                                 try
3278                                 {
3279                                         glArray->data(DrawTestSpec::TARGET_ELEMENT_ARRAY, indexArraySize, indexArray, DrawTestSpec::USAGE_STATIC_DRAW);
3280                                         rrArray->data(DrawTestSpec::TARGET_ELEMENT_ARRAY, indexArraySize, indexArray, DrawTestSpec::USAGE_STATIC_DRAW);
3281
3282                                         m_glArrayPack->render(spec.primitive, spec.drawMethod, 0, (int)primitiveElementCount, spec.indexType, indexPointer, spec.indexMin, spec.indexMax, spec.instanceCount, spec.indirectOffset, spec.baseVertex, coordScale, colorScale, glArray.get());
3283                                         m_rrArrayPack->render(spec.primitive, spec.drawMethod, 0, (int)primitiveElementCount, spec.indexType, indexPointer, spec.indexMin, spec.indexMax, spec.instanceCount, spec.indirectOffset, spec.baseVertex, coordScale, colorScale, rrArray.get());
3284
3285                                         delete [] indexArray;
3286                                         indexArray = NULL;
3287                                 }
3288                                 catch (...)
3289                                 {
3290                                         delete [] indexArray;
3291                                         throw;
3292                                 }
3293                         }
3294                         else
3295                         {
3296                                 m_glArrayPack->render(spec.primitive, spec.drawMethod, spec.first, (int)primitiveElementCount, DrawTestSpec::INDEXTYPE_LAST, DE_NULL, 0, 0, spec.instanceCount, spec.indirectOffset, 0, coordScale, colorScale, DE_NULL);
3297                                 m_rrArrayPack->render(spec.primitive, spec.drawMethod, spec.first, (int)primitiveElementCount, DrawTestSpec::INDEXTYPE_LAST, DE_NULL, 0, 0, spec.instanceCount, spec.indirectOffset, 0, coordScale, colorScale, DE_NULL);
3298                         }
3299                 }
3300                 catch (glu::Error& err)
3301                 {
3302                         // GL Errors are ok if the mode is not properly aligned
3303
3304                         const DrawTestSpec::CompatibilityTestType ctype = spec.isCompatibilityTest();
3305
3306                         m_testCtx.getLog() << TestLog::Message << "Got error: " << err.what() << TestLog::EndMessage;
3307
3308                         if (ctype == DrawTestSpec::COMPATIBILITY_UNALIGNED_OFFSET)
3309                                 m_result.addResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned buffers.");
3310                         else if (ctype == DrawTestSpec::COMPATIBILITY_UNALIGNED_STRIDE)
3311                                 m_result.addResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned stride.");
3312                         else
3313                                 throw;
3314                 }
3315         }
3316         else if (compareStep)
3317         {
3318                 if (!compare(spec.primitive))
3319                 {
3320                         const DrawTestSpec::CompatibilityTestType ctype = spec.isCompatibilityTest();
3321
3322                         if (ctype == DrawTestSpec::COMPATIBILITY_UNALIGNED_OFFSET)
3323                                 m_result.addResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned buffers.");
3324                         else if (ctype == DrawTestSpec::COMPATIBILITY_UNALIGNED_STRIDE)
3325                                 m_result.addResult(QP_TEST_RESULT_COMPATIBILITY_WARNING, "Failed to draw with unaligned stride.");
3326                         else
3327                                 m_result.addResult(QP_TEST_RESULT_FAIL, "Image comparison failed.");
3328                 }
3329         }
3330         else
3331         {
3332                 DE_ASSERT(false);
3333                 return STOP;
3334         }
3335
3336         m_result.setTestContextResult(m_testCtx);
3337
3338         m_iteration++;
3339         return iterateResult;
3340 }
3341
3342 static bool isBlack (const tcu::RGBA& c)
3343 {
3344         // ignore alpha channel
3345         return c.getRed() == 0 && c.getGreen() == 0 && c.getBlue() == 0;
3346 }
3347
3348 static bool isEdgeTripletComponent (int c1, int c2, int c3, int renderTargetDifference)
3349 {
3350         const int       roundingDifference      = 2 * renderTargetDifference; // src and dst pixels rounded to different directions
3351         const int       d1                                      = c2 - c1;
3352         const int       d2                                      = c3 - c2;
3353         const int       rampDiff                        = de::abs(d2 - d1);
3354
3355         return rampDiff > roundingDifference;
3356 }
3357
3358 static bool isEdgeTriplet (const tcu::RGBA& c1, const tcu::RGBA& c2, const tcu::RGBA& c3, const tcu::IVec3& renderTargetThreshold)
3359 {
3360         // black (background color) and non-black is always an edge
3361         {
3362                 const bool b1 = isBlack(c1);
3363                 const bool b2 = isBlack(c2);
3364                 const bool b3 = isBlack(c3);
3365
3366                 // both pixels with coverage and pixels without coverage
3367                 if ((b1 && b2 && b3) == false && (b1 || b2 || b3) == true)
3368                         return true;
3369                 // all black
3370                 if (b1 && b2 && b3)
3371                         return false;
3372                 // all with coverage
3373                 DE_ASSERT(!b1 && !b2 && !b3);
3374         }
3375
3376         // Color is always linearly interpolated => component values change nearly linearly
3377         // in any constant direction on triangle hull. (df/dx ~= C).
3378
3379         // Edge detection (this function) is run against the reference image
3380         // => no dithering to worry about
3381
3382         return  isEdgeTripletComponent(c1.getRed(),             c2.getRed(),    c3.getRed(),    renderTargetThreshold.x())      ||
3383                         isEdgeTripletComponent(c1.getGreen(),   c2.getGreen(),  c3.getGreen(),  renderTargetThreshold.y())      ||
3384                         isEdgeTripletComponent(c1.getBlue(),    c2.getBlue(),   c3.getBlue(),   renderTargetThreshold.z());
3385 }
3386
3387 static bool pixelNearEdge (int x, int y, const tcu::Surface& ref, const tcu::IVec3& renderTargetThreshold)
3388 {
3389         // should not be called for edge pixels
3390         DE_ASSERT(x >= 1 && x <= ref.getWidth()-2);
3391         DE_ASSERT(y >= 1 && y <= ref.getHeight()-2);
3392
3393         // horizontal
3394
3395         for (int dy = -1; dy < 2; ++dy)
3396         {
3397                 const tcu::RGBA c1 = ref.getPixel(x-1, y+dy);
3398                 const tcu::RGBA c2 = ref.getPixel(x,   y+dy);
3399                 const tcu::RGBA c3 = ref.getPixel(x+1, y+dy);
3400                 if (isEdgeTriplet(c1, c2, c3, renderTargetThreshold))
3401                         return true;
3402         }
3403
3404         // vertical
3405
3406         for (int dx = -1; dx < 2; ++dx)
3407         {
3408                 const tcu::RGBA c1 = ref.getPixel(x+dx, y-1);
3409                 const tcu::RGBA c2 = ref.getPixel(x+dx, y);
3410                 const tcu::RGBA c3 = ref.getPixel(x+dx, y+1);
3411                 if (isEdgeTriplet(c1, c2, c3, renderTargetThreshold))
3412                         return true;
3413         }
3414
3415         return false;
3416 }
3417
3418 static deUint32 getVisualizationGrayscaleColor (const tcu::RGBA& c)
3419 {
3420         // make triangle coverage and error pixels obvious by converting coverage to grayscale
3421         if (isBlack(c))
3422                 return 0;
3423         else
3424                 return 50u + (deUint32)(c.getRed() + c.getBlue() + c.getGreen()) / 8u;
3425 }
3426
3427 static bool pixelNearLineIntersection (int x, int y, const tcu::Surface& target)
3428 {
3429         // should not be called for edge pixels
3430         DE_ASSERT(x >= 1 && x <= target.getWidth()-2);
3431         DE_ASSERT(y >= 1 && y <= target.getHeight()-2);
3432
3433         int coveredPixels = 0;
3434
3435         for (int dy = -1; dy < 2; dy++)
3436         for (int dx = -1; dx < 2; dx++)
3437         {
3438                 const bool targetCoverage = !isBlack(target.getPixel(x+dx, y+dy));
3439                 if (targetCoverage)
3440                 {
3441                         ++coveredPixels;
3442
3443                         // A single thin line cannot have more than 3 covered pixels in a 3x3 area
3444                         if (coveredPixels >= 4)
3445                                 return true;
3446                 }
3447         }
3448
3449         return false;
3450 }
3451
3452 static inline bool colorsEqual (const tcu::RGBA& colorA, const tcu::RGBA& colorB, const tcu::IVec3& compareThreshold)
3453 {
3454         enum
3455         {
3456                 TCU_RGBA_RGB_MASK = tcu::RGBA::RED_MASK | tcu::RGBA::GREEN_MASK | tcu::RGBA::BLUE_MASK
3457         };
3458
3459         return tcu::compareThresholdMasked(colorA, colorB, tcu::RGBA(compareThreshold.x(), compareThreshold.y(), compareThreshold.z(), 0), TCU_RGBA_RGB_MASK);
3460 }
3461
3462 // search 3x3 are for matching color
3463 static bool pixelNeighborhoodContainsColor (const tcu::Surface& target, int x, int y, const tcu::RGBA& color, const tcu::IVec3& compareThreshold)
3464 {
3465         // should not be called for edge pixels
3466         DE_ASSERT(x >= 1 && x <= target.getWidth()-2);
3467         DE_ASSERT(y >= 1 && y <= target.getHeight()-2);
3468
3469         for (int dy = -1; dy < 2; dy++)
3470         for (int dx = -1; dx < 2; dx++)
3471         {
3472                 const tcu::RGBA targetCmpPixel = target.getPixel(x+dx, y+dy);
3473                 if (colorsEqual(color, targetCmpPixel, compareThreshold))
3474                         return true;
3475         }
3476
3477         return false;
3478 }
3479
3480 // search 3x3 are for matching coverage (coverage == (color != background color))
3481 static bool pixelNeighborhoodContainsCoverage (const tcu::Surface& target, int x, int y, bool coverage)
3482 {
3483         // should not be called for edge pixels
3484         DE_ASSERT(x >= 1 && x <= target.getWidth()-2);
3485         DE_ASSERT(y >= 1 && y <= target.getHeight()-2);
3486
3487         for (int dy = -1; dy < 2; dy++)
3488         for (int dx = -1; dx < 2; dx++)
3489         {
3490                 const bool targetCmpCoverage = !isBlack(target.getPixel(x+dx, y+dy));
3491                 if (targetCmpCoverage == coverage)
3492                         return true;
3493         }
3494
3495         return false;
3496 }
3497
3498 static bool edgeRelaxedImageCompare (tcu::TestLog& log, const char* imageSetName, const char* imageSetDesc, const tcu::Surface& reference, const tcu::Surface& result, const tcu::IVec3& compareThreshold, const tcu::IVec3& renderTargetThreshold, int maxAllowedInvalidPixels)
3499 {
3500         DE_ASSERT(result.getWidth() == reference.getWidth() && result.getHeight() == reference.getHeight());
3501
3502         const tcu::IVec4                                green                                           (0, 255, 0, 255);
3503         const tcu::IVec4                                red                                                     (255, 0, 0, 255);
3504         const int                                               width                                           = reference.getWidth();
3505         const int                                               height                                          = reference.getHeight();
3506         tcu::TextureLevel                               errorMask                                       (tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), width, height);
3507         const tcu::PixelBufferAccess    errorAccess                                     = errorMask.getAccess();
3508         int                                                             numFailingPixels                        = 0;
3509
3510         // clear errormask edges which would otherwise be transparent
3511
3512         tcu::clear(tcu::getSubregion(errorAccess, 0,                    0,                      width,  1),                     green);
3513         tcu::clear(tcu::getSubregion(errorAccess, 0,                    height-1,       width,  1),                     green);
3514         tcu::clear(tcu::getSubregion(errorAccess, 0,                    0,                      1,              height),        green);
3515         tcu::clear(tcu::getSubregion(errorAccess, width-1,              0,                      1,              height),        green);
3516
3517         // skip edge pixels since coverage on edge cannot be verified
3518
3519         for (int y = 1; y < height - 1; ++y)
3520         for (int x = 1; x < width - 1; ++x)
3521         {
3522                 const tcu::RGBA refPixel                        = reference.getPixel(x, y);
3523                 const tcu::RGBA screenPixel                     = result.getPixel(x, y);
3524                 const bool              directMatch                     = colorsEqual(refPixel, screenPixel, compareThreshold);
3525                 const bool              isOkReferencePixel      = directMatch || pixelNeighborhoodContainsColor(result, x, y, refPixel, compareThreshold);                      // screen image has a matching pixel nearby (~= If something is drawn on reference, it must be drawn to screen too.)
3526                 const bool              isOkScreenPixel         = directMatch || pixelNeighborhoodContainsColor(reference, x, y, screenPixel, compareThreshold);        // reference image has a matching pixel nearby (~= If something is drawn on screen, it must be drawn to reference too.)
3527
3528                 if (isOkScreenPixel && isOkReferencePixel)
3529                 {
3530                         // pixel valid, write greenish pixels to make the result image easier to read
3531                         const deUint32 grayscaleValue = getVisualizationGrayscaleColor(screenPixel);
3532                         errorAccess.setPixel(tcu::UVec4(grayscaleValue, 255, grayscaleValue, 255), x, y);
3533                 }
3534                 else if (!pixelNearEdge(x, y, reference, renderTargetThreshold))
3535                 {
3536                         // non-edge pixel values must be within threshold of the reference values
3537                         errorAccess.setPixel(red, x, y);
3538                         ++numFailingPixels;
3539                 }
3540                 else
3541                 {
3542                         // we are on/near an edge, verify only coverage (coverage == not background colored)
3543                         const bool      referenceCoverage               = !isBlack(refPixel);
3544                         const bool      screenCoverage                  = !isBlack(screenPixel);
3545                         const bool      isOkReferenceCoverage   = pixelNeighborhoodContainsCoverage(result, x, y, referenceCoverage);   // Check reference pixel against screen pixel
3546                         const bool      isOkScreenCoverage              = pixelNeighborhoodContainsCoverage(reference, x, y, screenCoverage);   // Check screen pixels against reference pixel
3547
3548                         if (isOkScreenCoverage && isOkReferenceCoverage)
3549                         {
3550                                 // pixel valid, write greenish pixels to make the result image easier to read
3551                                 const deUint32 grayscaleValue = getVisualizationGrayscaleColor(screenPixel);
3552                                 errorAccess.setPixel(tcu::UVec4(grayscaleValue, 255, grayscaleValue, 255), x, y);
3553                         }
3554                         else
3555                         {
3556                                 // coverage does not match
3557                                 errorAccess.setPixel(red, x, y);
3558                                 ++numFailingPixels;
3559                         }
3560                 }
3561         }
3562
3563         log     << TestLog::Message
3564                 << "Comparing images:\n"
3565                 << "\tallowed deviation in pixel positions = 1\n"
3566                 << "\tnumber of allowed invalid pixels = " << maxAllowedInvalidPixels << "\n"
3567                 << "\tnumber of invalid pixels = " << numFailingPixels
3568                 << TestLog::EndMessage;
3569
3570         if (numFailingPixels > maxAllowedInvalidPixels)
3571         {
3572                 log << TestLog::Message
3573                         << "Image comparison failed. Color threshold = (" << compareThreshold.x() << ", " << compareThreshold.y() << ", " << compareThreshold.z() << ")"
3574                         << TestLog::EndMessage
3575                         << TestLog::ImageSet(imageSetName, imageSetDesc)
3576                         << TestLog::Image("Result",             "Result",               result)
3577                         << TestLog::Image("Reference",  "Reference",    reference)
3578                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
3579                         << TestLog::EndImageSet;
3580
3581                 return false;
3582         }
3583         else
3584         {
3585                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
3586                         << TestLog::Image("Result", "Result", result)
3587                         << TestLog::EndImageSet;
3588
3589                 return true;
3590         }
3591 }
3592
3593 static bool intersectionRelaxedLineImageCompare (tcu::TestLog& log, const char* imageSetName, const char* imageSetDesc, const tcu::Surface& reference, const tcu::Surface& result, const tcu::IVec3& compareThreshold, int maxAllowedInvalidPixels)
3594 {
3595         DE_ASSERT(result.getWidth() == reference.getWidth() && result.getHeight() == reference.getHeight());
3596
3597         const tcu::IVec4                                green                                           (0, 255, 0, 255);
3598         const tcu::IVec4                                red                                                     (255, 0, 0, 255);
3599         const int                                               width                                           = reference.getWidth();
3600         const int                                               height                                          = reference.getHeight();
3601         tcu::TextureLevel                               errorMask                                       (tcu::TextureFormat(tcu::TextureFormat::RGB, tcu::TextureFormat::UNORM_INT8), width, height);
3602         const tcu::PixelBufferAccess    errorAccess                                     = errorMask.getAccess();
3603         int                                                             numFailingPixels                        = 0;
3604
3605         // clear errormask edges which would otherwise be transparent
3606
3607         tcu::clear(tcu::getSubregion(errorAccess, 0,                    0,                      width,  1),                     green);
3608         tcu::clear(tcu::getSubregion(errorAccess, 0,                    height-1,       width,  1),                     green);
3609         tcu::clear(tcu::getSubregion(errorAccess, 0,                    0,                      1,              height),        green);
3610         tcu::clear(tcu::getSubregion(errorAccess, width-1,              0,                      1,              height),        green);
3611
3612         // skip edge pixels since coverage on edge cannot be verified
3613
3614         for (int y = 1; y < height - 1; ++y)
3615         for (int x = 1; x < width - 1; ++x)
3616         {
3617                 const tcu::RGBA refPixel                        = reference.getPixel(x, y);
3618                 const tcu::RGBA screenPixel                     = result.getPixel(x, y);
3619                 const bool              directMatch                     = colorsEqual(refPixel, screenPixel, compareThreshold);
3620                 const bool              isOkScreenPixel         = directMatch || pixelNeighborhoodContainsColor(reference, x, y, screenPixel, compareThreshold);        // reference image has a matching pixel nearby (~= If something is drawn on screen, it must be drawn to reference too.)
3621                 const bool              isOkReferencePixel      = directMatch || pixelNeighborhoodContainsColor(result, x, y, refPixel, compareThreshold);                      // screen image has a matching pixel nearby (~= If something is drawn on reference, it must be drawn to screen too.)
3622
3623                 if (isOkScreenPixel && isOkReferencePixel)
3624                 {
3625                         // pixel valid, write greenish pixels to make the result image easier to read
3626                         const deUint32 grayscaleValue = getVisualizationGrayscaleColor(screenPixel);
3627                         errorAccess.setPixel(tcu::UVec4(grayscaleValue, 255, grayscaleValue, 255), x, y);
3628                 }
3629                 else if (!pixelNearLineIntersection(x, y, reference) &&
3630                                  !pixelNearLineIntersection(x, y, result))
3631                 {
3632                         // non-intersection pixel values must be within threshold of the reference values
3633                         errorAccess.setPixel(red, x, y);
3634                         ++numFailingPixels;
3635                 }
3636                 else
3637                 {
3638                         // pixel is near a line intersection
3639                         // we are on/near an edge, verify only coverage (coverage == not background colored)
3640                         const bool      referenceCoverage               = !isBlack(refPixel);
3641                         const bool      screenCoverage                  = !isBlack(screenPixel);
3642                         const bool      isOkScreenCoverage              = pixelNeighborhoodContainsCoverage(reference, x, y, screenCoverage);   // Check screen pixels against reference pixel
3643                         const bool      isOkReferenceCoverage   = pixelNeighborhoodContainsCoverage(result, x, y, referenceCoverage);   // Check reference pixel against screen pixel
3644
3645                         if (isOkScreenCoverage && isOkReferenceCoverage)
3646                         {
3647                                 // pixel valid, write greenish pixels to make the result image easier to read
3648                                 const deUint32 grayscaleValue = getVisualizationGrayscaleColor(screenPixel);
3649                                 errorAccess.setPixel(tcu::UVec4(grayscaleValue, 255, grayscaleValue, 255), x, y);
3650                         }
3651                         else
3652                         {
3653                                 // coverage does not match
3654                                 errorAccess.setPixel(red, x, y);
3655                                 ++numFailingPixels;
3656                         }
3657                 }
3658         }
3659
3660         log     << TestLog::Message
3661                 << "Comparing images:\n"
3662                 << "\tallowed deviation in pixel positions = 1\n"
3663                 << "\tnumber of allowed invalid pixels = " << maxAllowedInvalidPixels << "\n"
3664                 << "\tnumber of invalid pixels = " << numFailingPixels
3665                 << TestLog::EndMessage;
3666
3667         if (numFailingPixels > maxAllowedInvalidPixels)
3668         {
3669                 log << TestLog::Message
3670                         << "Image comparison failed. Color threshold = (" << compareThreshold.x() << ", " << compareThreshold.y() << ", " << compareThreshold.z() << ")"
3671                         << TestLog::EndMessage
3672                         << TestLog::ImageSet(imageSetName, imageSetDesc)
3673                         << TestLog::Image("Result",             "Result",               result)
3674                         << TestLog::Image("Reference",  "Reference",    reference)
3675                         << TestLog::Image("ErrorMask",  "Error mask",   errorMask)
3676                         << TestLog::EndImageSet;
3677
3678                 return false;
3679         }
3680         else
3681         {
3682                 log << TestLog::ImageSet(imageSetName, imageSetDesc)
3683                         << TestLog::Image("Result", "Result", result)
3684                         << TestLog::EndImageSet;
3685
3686                 return true;
3687         }
3688 }
3689
3690 bool DrawTest::compare (gls::DrawTestSpec::Primitive primitiveType)
3691 {
3692         const tcu::Surface&     ref             = m_rrArrayPack->getSurface();
3693         const tcu::Surface&     screen  = m_glArrayPack->getSurface();
3694
3695         if (m_renderCtx.getRenderTarget().getNumSamples() > 1)
3696         {
3697                 // \todo [mika] Improve compare when using multisampling
3698                 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;
3699                 return tcu::fuzzyCompare(m_testCtx.getLog(), "Compare Results", "Compare Results", ref.getAccess(), screen.getAccess(), 0.3f, tcu::COMPARE_LOG_RESULT);
3700         }
3701         else
3702         {
3703                 const PrimitiveClass    primitiveClass                                                  = getDrawPrimitiveClass(primitiveType);
3704                 const int                               maxAllowedInvalidPixelsWithPoints               = 0;    //!< points are unlikely to have overlapping fragments
3705                 const int                               maxAllowedInvalidPixelsWithLines                = 5;    //!< line are allowed to have a few bad pixels
3706                 const int                               maxAllowedInvalidPixelsWithTriangles    = 10;
3707
3708                 switch (primitiveClass)
3709                 {
3710                         case PRIMITIVECLASS_POINT:
3711                         {
3712                                 // Point are extremely unlikely to have overlapping regions, don't allow any no extra / missing pixels
3713                                 return tcu::intThresholdPositionDeviationErrorThresholdCompare(m_testCtx.getLog(),
3714                                                                                                                                                            "CompareResult",
3715                                                                                                                                                            "Result of rendering",
3716                                                                                                                                                            ref.getAccess(),
3717                                                                                                                                                            screen.getAccess(),
3718                                                                                                                                                            tcu::UVec4(m_maxDiffRed, m_maxDiffGreen, m_maxDiffBlue, 256),
3719                                                                                                                                                            tcu::IVec3(1, 1, 0),                                 //!< 3x3 search kernel
3720                                                                                                                                                            true,                                                                //!< relax comparison on the image boundary
3721                                                                                                                                                            maxAllowedInvalidPixelsWithPoints,   //!< error threshold
3722                                                                                                                                                            tcu::COMPARE_LOG_RESULT);
3723                         }
3724
3725                         case PRIMITIVECLASS_LINE:
3726                         {
3727                                 // Lines can potentially have a large number of overlapping pixels. Pixel comparison may potentially produce
3728                                 // false negatives in such pixels if for example the pixel in question is overdrawn by another line in the
3729                                 // reference image but not in the resultin image. Relax comparison near line intersection points (areas) and
3730                                 // compare only coverage, not color, in such pixels
3731                                 return intersectionRelaxedLineImageCompare(m_testCtx.getLog(),
3732                                                                                                                    "CompareResult",
3733                                                                                                                    "Result of rendering",
3734                                                                                                                    ref,
3735                                                                                                                    screen,
3736                                                                                                                    tcu::IVec3(m_maxDiffRed, m_maxDiffGreen, m_maxDiffBlue),
3737                                                                                                                    maxAllowedInvalidPixelsWithLines);
3738                         }
3739
3740                         case PRIMITIVECLASS_TRIANGLE:
3741                         {
3742                                 // Triangles are likely to partially or fully overlap. Pixel difference comparison is fragile in pixels
3743                                 // where there could be potential overlapping since the  pixels might be covered by one triangle in the
3744                                 // reference image and by the other in the result image. Relax comparsion near primitive edges and
3745                                 // compare only coverage, not color, in such pixels.
3746                                 const tcu::IVec3        renderTargetThreshold                                   = m_renderCtx.getRenderTarget().getPixelFormat().getColorThreshold().toIVec().xyz();
3747
3748                                 return edgeRelaxedImageCompare(m_testCtx.getLog(),
3749                                                                                            "CompareResult",
3750                                                                                            "Result of rendering",
3751                                                                                            ref,
3752                                                                                            screen,
3753                                                                                            tcu::IVec3(m_maxDiffRed, m_maxDiffGreen, m_maxDiffBlue),
3754                                                                                            renderTargetThreshold,
3755                                                                                            maxAllowedInvalidPixelsWithTriangles);
3756                         }
3757
3758                         default:
3759                                 DE_ASSERT(false);
3760                                 return false;
3761                 }
3762         }
3763 }
3764
3765 float DrawTest::getCoordScale (const DrawTestSpec& spec) const
3766 {
3767         float maxValue = 1.0f;
3768
3769         for (int arrayNdx = 0; arrayNdx < (int)spec.attribs.size(); arrayNdx++)
3770         {
3771                 DrawTestSpec::AttributeSpec attribSpec          = spec.attribs[arrayNdx];
3772                 const bool                                      isPositionAttr  = (arrayNdx == 0) || (attribSpec.additionalPositionAttribute);
3773                 float                                           attrMaxValue    = 0;
3774
3775                 if (!isPositionAttr)
3776                         continue;
3777
3778                 if (attribSpec.inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10)
3779                 {
3780                         if (attribSpec.normalize)
3781                                 attrMaxValue += 1.0f;
3782                         else
3783                                 attrMaxValue += 1024.0f;
3784                 }
3785                 else if (attribSpec.inputType == DrawTestSpec::INPUTTYPE_INT_2_10_10_10)
3786                 {
3787                         if (attribSpec.normalize)
3788                                 attrMaxValue += 1.0f;
3789                         else
3790                                 attrMaxValue += 512.0f;
3791                 }
3792                 else
3793                 {
3794                         const float max = GLValue::getMaxValue(attribSpec.inputType).toFloat();
3795
3796                         attrMaxValue += (attribSpec.normalize && !inputTypeIsFloatType(attribSpec.inputType)) ? (1.0f) : (max * 1.1f);
3797                 }
3798
3799                 if (attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_VEC3 || attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_VEC4
3800                         || attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_IVEC3 || attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_IVEC4
3801                         || attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_UVEC3 || attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_UVEC4)
3802                                 attrMaxValue *= 2;
3803
3804                 maxValue += attrMaxValue;
3805         }
3806
3807         return 1.0f / maxValue;
3808 }
3809
3810 float DrawTest::getColorScale (const DrawTestSpec& spec) const
3811 {
3812         float colorScale = 1.0f;
3813
3814         for (int arrayNdx = 1; arrayNdx < (int)spec.attribs.size(); arrayNdx++)
3815         {
3816                 DrawTestSpec::AttributeSpec attribSpec          = spec.attribs[arrayNdx];
3817                 const bool                                      isPositionAttr  = (arrayNdx == 0) || (attribSpec.additionalPositionAttribute);
3818
3819                 if (isPositionAttr)
3820                         continue;
3821
3822                 if (attribSpec.inputType == DrawTestSpec::INPUTTYPE_UNSIGNED_INT_2_10_10_10)
3823                 {
3824                         if (!attribSpec.normalize)
3825                                 colorScale *= 1.0f / 1024.0f;
3826                 }
3827                 else if (attribSpec.inputType == DrawTestSpec::INPUTTYPE_INT_2_10_10_10)
3828                 {
3829                         if (!attribSpec.normalize)
3830                                 colorScale *= 1.0f / 512.0f;
3831                 }
3832                 else
3833                 {
3834                         const float max = GLValue::getMaxValue(attribSpec.inputType).toFloat();
3835
3836                         colorScale *= (attribSpec.normalize && !inputTypeIsFloatType(attribSpec.inputType) ? 1.0f : float(1.0 / double(max)));
3837                         if (attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_VEC4 ||
3838                                 attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_UVEC4 ||
3839                                 attribSpec.outputType == DrawTestSpec::OUTPUTTYPE_IVEC4)
3840                                 colorScale *= (attribSpec.normalize && !inputTypeIsFloatType(attribSpec.inputType) ? 1.0f : float(1.0 / double(max)));
3841                 }
3842         }
3843
3844         return colorScale;
3845 }
3846
3847 } // gls
3848 } // deqp