modules/gles2/functional/es2fBufferTestUtil.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 2.0 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 Buffer test utilities.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es2fBufferTestUtil.hpp"
  25 #include "tcuRandomValueIterator.hpp"
  26 #include "tcuSurface.hpp"
  27 #include "tcuImageCompare.hpp"
  28 #include "tcuVector.hpp"
  29 #include "tcuFormatUtil.hpp"
  30 #include "tcuTextureUtil.hpp"
  31 #include "tcuRenderTarget.hpp"
  32 #include "gluPixelTransfer.hpp"
  33 #include "gluRenderContext.hpp"
  34 #include "gluStrUtil.hpp"
  35 #include "gluShaderProgram.hpp"
  36 #include "deMemory.h"
  37 #include "deStringUtil.hpp"
  38
  39 #include <algorithm>
  40
  41 #include "glwEnums.hpp"
  42 #include "glwFunctions.hpp"
  43
  44 namespace deqp
  45 {
  46 namespace gles2
  47 {
  48 namespace Functional
  49 {
  50 namespace BufferTestUtil
  51 {
  52
  53 enum
  54 {
  55         VERIFY_QUAD_SIZE                                        = 8,            //!< Quad size in VertexArrayVerifier
  56         MAX_LINES_PER_INDEX_ARRAY_DRAW          = 128,          //!< Maximum number of lines per one draw in IndexArrayVerifier
  57         INDEX_ARRAY_DRAW_VIEWPORT_WIDTH         = 128,
  58         INDEX_ARRAY_DRAW_VIEWPORT_HEIGHT        = 128
  59 };
  60
  61 static const bool LOG_VERIFIER_CALLS = false; //! \note Especially array verifier generates a lot of calls.
  62
  63 using tcu::TestLog;
  64 using std::vector;
  65 using std::string;
  66 using std::set;
  67
  68 // Helper functions.
  69
  70 void fillWithRandomBytes (deUint8* ptr, int numBytes, deUint32 seed)
  71 {
  72         std::copy(tcu::RandomValueIterator<deUint8>::begin(seed, numBytes), tcu::RandomValueIterator<deUint8>::end(), ptr);
  73 }
  74
  75 bool compareByteArrays (tcu::TestLog& log, const deUint8* resPtr, const deUint8* refPtr, int numBytes)
  76 {
  77         bool                    isOk                    = true;
  78         const int               maxSpanLen              = 8;
  79         const int               maxDiffSpans    = 4;
  80         int                             numDiffSpans    = 0;
  81         int                             diffSpanStart   = -1;
  82         int                             ndx                             = 0;
  83
  84         log << TestLog::Section("Verify", "Verification result");
  85
  86         for (;ndx < numBytes; ndx++)
  87         {
  88                 if (resPtr[ndx] != refPtr[ndx])
  89                 {
  90                         if (diffSpanStart < 0)
  91                                 diffSpanStart = ndx;
  92
  93                         isOk = false;
  94                 }
  95                 else if (diffSpanStart >= 0)
  96                 {
  97                         if (numDiffSpans < maxDiffSpans)
  98                         {
  99                                 int len                 = ndx-diffSpanStart;
 100                                 int     printLen        = de::min(len, maxSpanLen);
 101
 102                                 log << TestLog::Message << len << " byte difference at offset " << diffSpanStart << "\n"
 103                                                                                 << "  expected "        << tcu::formatArray(tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart+printLen)) << "\n"
 104                                                                                 << "  got "                     << tcu::formatArray(tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart+printLen))
 105                                         << TestLog::EndMessage;
 106                         }
 107                         else
 108                                 log << TestLog::Message << "(output too long, truncated)" << TestLog::EndMessage;
 109
 110                         numDiffSpans    += 1;
 111                         diffSpanStart    = -1;
 112                 }
 113         }
 114
 115         if (diffSpanStart >= 0)
 116         {
 117                 if (numDiffSpans < maxDiffSpans)
 118                 {
 119                                 int len                 = ndx-diffSpanStart;
 120                                 int     printLen        = de::min(len, maxSpanLen);
 121
 122                                 log << TestLog::Message << len << " byte difference at offset " << diffSpanStart << "\n"
 123                                                                                 << "  expected "        << tcu::formatArray(tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(refPtr+diffSpanStart+printLen)) << "\n"
 124                                                                                 << "  got "                     << tcu::formatArray(tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart), tcu::Format::HexIterator<deUint8>(resPtr+diffSpanStart+printLen))
 125                                         << TestLog::EndMessage;
 126                 }
 127                 else
 128                         log << TestLog::Message << "(output too long, truncated)" << TestLog::EndMessage;
 129         }
 130
 131         log << TestLog::Message << (isOk ? "Verification passed." : "Verification FAILED!") << TestLog::EndMessage;
 132         log << TestLog::EndSection;
 133
 134         return isOk;
 135 }
 136
 137 const char* getBufferTargetName (deUint32 target)
 138 {
 139         switch (target)
 140         {
 141                 case GL_ARRAY_BUFFER:                           return "array";
 142                 case GL_ELEMENT_ARRAY_BUFFER:           return "element_array";
 143                 default:
 144                         DE_ASSERT(false);
 145                         return DE_NULL;
 146         }
 147 }
 148
 149 const char* getUsageHintName (deUint32 hint)
 150 {
 151         switch (hint)
 152         {
 153                 case GL_STREAM_DRAW:    return "stream_draw";
 154                 case GL_STATIC_DRAW:    return "static_draw";
 155                 case GL_DYNAMIC_DRAW:   return "dynamic_draw";
 156                 default:
 157                         DE_ASSERT(false);
 158                         return DE_NULL;
 159         }
 160 }
 161
 162 // BufferCase
 163
 164 BufferCase::BufferCase (Context& context, const char* name, const char* description)
 165         : TestCase                      (context, name, description)
 166         , CallLogWrapper        (context.getRenderContext().getFunctions(), m_context.getTestContext().getLog())
 167 {
 168 }
 169
 170 BufferCase::~BufferCase (void)
 171 {
 172         enableLogging(false);
 173         BufferCase::deinit();
 174 }
 175
 176 void BufferCase::init (void)
 177 {
 178         enableLogging(true);
 179 }
 180
 181 void BufferCase::deinit (void)
 182 {
 183         for (set<deUint32>::const_iterator bufIter = m_allocatedBuffers.begin(); bufIter != m_allocatedBuffers.end(); bufIter++)
 184                 glDeleteBuffers(1, &(*bufIter));
 185 }
 186
 187 deUint32 BufferCase::genBuffer (void)
 188 {
 189         deUint32 buf = 0;
 190         glGenBuffers(1, &buf);
 191         if (buf != 0)
 192         {
 193                 try
 194                 {
 195                         m_allocatedBuffers.insert(buf);
 196                 }
 197                 catch (const std::exception&)
 198                 {
 199                         glDeleteBuffers(1, &buf);
 200                         throw;
 201                 }
 202         }
 203         return buf;
 204 }
 205
 206 void BufferCase::deleteBuffer (deUint32 buffer)
 207 {
 208         glDeleteBuffers(1, &buffer);
 209         m_allocatedBuffers.erase(buffer);
 210 }
 211
 212 void BufferCase::checkError (void)
 213 {
 214         glw::GLenum err = glGetError();
 215         if (err != GL_NO_ERROR)
 216                 throw tcu::TestError(string("Got ") + glu::getErrorStr(err).toString());
 217 }
 218
 219 // ReferenceBuffer
 220
 221 void ReferenceBuffer::setSize (int numBytes)
 222 {
 223         m_data.resize(numBytes);
 224 }
 225
 226 void ReferenceBuffer::setData (int numBytes, const deUint8* bytes)
 227 {
 228         m_data.resize(numBytes);
 229         std::copy(bytes, bytes+numBytes, m_data.begin());
 230 }
 231
 232 void ReferenceBuffer::setSubData (int offset, int numBytes, const deUint8* bytes)
 233 {
 234         DE_ASSERT(de::inBounds(offset, 0, (int)m_data.size()) && de::inRange(offset+numBytes, offset, (int)m_data.size()));
 235         std::copy(bytes, bytes+numBytes, m_data.begin()+offset);
 236 }
 237
 238 // BufferVerifierBase
 239
 240 BufferVerifierBase::BufferVerifierBase (Context& context)
 241         : CallLogWrapper        (context.getRenderContext().getFunctions(), context.getTestContext().getLog())
 242         , m_context                     (context)
 243 {
 244         enableLogging(LOG_VERIFIER_CALLS);
 245 }
 246
 247 // BufferVerifier
 248
 249 BufferVerifier::BufferVerifier (Context& context, VerifyType verifyType)
 250         : m_verifier(DE_NULL)
 251 {
 252         switch (verifyType)
 253         {
 254                 case VERIFY_AS_VERTEX_ARRAY:    m_verifier = new VertexArrayVerifier(context);  break;
 255                 case VERIFY_AS_INDEX_ARRAY:             m_verifier = new IndexArrayVerifier     (context);      break;
 256                 default:
 257                         TCU_FAIL("Unsupported verifier");
 258         }
 259 }
 260
 261 BufferVerifier::~BufferVerifier (void)
 262 {
 263         delete m_verifier;
 264 }
 265
 266 bool BufferVerifier::verify (deUint32 buffer, const deUint8* reference, int offset, int numBytes)
 267 {
 268         DE_ASSERT(numBytes >= getMinSize());
 269         DE_ASSERT(offset%getAlignment() == 0);
 270         DE_ASSERT((offset+numBytes)%getAlignment() == 0);
 271         return m_verifier->verify(buffer, reference, offset, numBytes);
 272 }
 273
 274 // VertexArrayVerifier
 275
 276 VertexArrayVerifier::VertexArrayVerifier (Context& context)
 277         : BufferVerifierBase    (context)
 278         , m_program                             (DE_NULL)
 279         , m_posLoc                              (0)
 280         , m_byteVecLoc                  (0)
 281 {
 282         m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(
 283                 "attribute highp vec2 a_position;\n"
 284                 "attribute mediump vec3 a_byteVec;\n"
 285                 "varying mediump vec3 v_byteVec;\n"
 286                 "void main (void)\n"
 287                 "{\n"
 288                 "       gl_Position = vec4(a_position, 0.0, 1.0);\n"
 289                 "       v_byteVec = a_byteVec;\n"
 290                 "}\n",
 291
 292                 "varying mediump vec3 v_byteVec;\n"
 293                 "void main (void)\n"
 294                 "{\n"
 295                 "       gl_FragColor = vec4(v_byteVec, 1.0);\n"
 296                 "}\n"));
 297
 298         if (!m_program->isOk())
 299         {
 300                 m_context.getTestContext().getLog() << *m_program;
 301                 delete m_program;
 302                 TCU_FAIL("Compile failed");
 303         }
 304
 305         const glw::Functions& funcs = context.getRenderContext().getFunctions();
 306         m_posLoc                = funcs.getAttribLocation(m_program->getProgram(), "a_position");
 307         m_byteVecLoc    = funcs.getAttribLocation(m_program->getProgram(), "a_byteVec");
 308 }
 309
 310 VertexArrayVerifier::~VertexArrayVerifier (void)
 311 {
 312         delete m_program;
 313 }
 314
 315 static void computePositions (vector<tcu::Vec2>& positions, int gridSizeX, int gridSizeY)
 316 {
 317         positions.resize(gridSizeX*gridSizeY*4);
 318
 319         for (int y = 0; y < gridSizeY; y++)
 320         for (int x = 0; x < gridSizeX; x++)
 321         {
 322                 float   sx0                     = (float)(x+0) / (float)gridSizeX;
 323                 float   sy0                     = (float)(y+0) / (float)gridSizeY;
 324                 float   sx1                     = (float)(x+1) / (float)gridSizeX;
 325                 float   sy1                     = (float)(y+1) / (float)gridSizeY;
 326                 float   fx0                     = 2.0f * sx0 - 1.0f;
 327                 float   fy0                     = 2.0f * sy0 - 1.0f;
 328                 float   fx1                     = 2.0f * sx1 - 1.0f;
 329                 float   fy1                     = 2.0f * sy1 - 1.0f;
 330                 int             baseNdx         = (y * gridSizeX + x)*4;
 331
 332                 positions[baseNdx+0] = tcu::Vec2(fx0, fy0);
 333                 positions[baseNdx+1] = tcu::Vec2(fx0, fy1);
 334                 positions[baseNdx+2] = tcu::Vec2(fx1, fy0);
 335                 positions[baseNdx+3] = tcu::Vec2(fx1, fy1);
 336         }
 337 }
 338
 339 static void computeIndices (vector<deUint16>& indices, int gridSizeX, int gridSizeY)
 340 {
 341         indices.resize(3 * 2 * gridSizeX * gridSizeY);
 342
 343         for (int quadNdx = 0; quadNdx < gridSizeX*gridSizeY; quadNdx++)
 344         {
 345                 int v00 = quadNdx*4 + 0;
 346                 int v01 = quadNdx*4 + 1;
 347                 int v10 = quadNdx*4 + 2;
 348                 int v11 = quadNdx*4 + 3;
 349
 350                 DE_ASSERT(v11 < (1<<16));
 351
 352                 indices[quadNdx*6 + 0] = (deUint16)v10;
 353                 indices[quadNdx*6 + 1] = (deUint16)v00;
 354                 indices[quadNdx*6 + 2] = (deUint16)v01;
 355
 356                 indices[quadNdx*6 + 3] = (deUint16)v10;
 357                 indices[quadNdx*6 + 4] = (deUint16)v01;
 358                 indices[quadNdx*6 + 5] = (deUint16)v11;
 359         }
 360 }
 361
 362 static inline tcu::Vec4 fetchVtxColor (const deUint8* ptr, int vtxNdx)
 363 {
 364         return tcu::RGBA(*(ptr + vtxNdx*3 + 0),
 365                                          *(ptr + vtxNdx*3 + 1),
 366                                          *(ptr + vtxNdx*3 + 2),
 367                                          255).toVec();
 368 }
 369
 370 static void renderQuadGridReference (tcu::Surface& dst, int numQuads, int rowLength, const deUint8* inPtr)
 371 {
 372         using tcu::Vec4;
 373
 374         dst.setSize(rowLength*VERIFY_QUAD_SIZE, (numQuads/rowLength + (numQuads%rowLength != 0 ? 1 : 0))*VERIFY_QUAD_SIZE);
 375
 376         tcu::PixelBufferAccess dstAccess = dst.getAccess();
 377         tcu::clear(dstAccess, tcu::IVec4(0, 0, 0, 0xff));
 378
 379         for (int quadNdx = 0; quadNdx < numQuads; quadNdx++)
 380         {
 381                 int             x0              = (quadNdx%rowLength)*VERIFY_QUAD_SIZE;
 382                 int             y0              = (quadNdx/rowLength)*VERIFY_QUAD_SIZE;
 383                 Vec4    v00             = fetchVtxColor(inPtr, quadNdx*4 + 0);
 384                 Vec4    v10             = fetchVtxColor(inPtr, quadNdx*4 + 1);
 385                 Vec4    v01             = fetchVtxColor(inPtr, quadNdx*4 + 2);
 386                 Vec4    v11             = fetchVtxColor(inPtr, quadNdx*4 + 3);
 387
 388                 for (int y = 0; y < VERIFY_QUAD_SIZE; y++)
 389                 for (int x = 0; x < VERIFY_QUAD_SIZE; x++)
 390                 {
 391                         float           fx              = ((float)x+0.5f) / (float)VERIFY_QUAD_SIZE;
 392                         float           fy              = ((float)y+0.5f) / (float)VERIFY_QUAD_SIZE;
 393
 394                         bool            tri             = fx + fy <= 1.0f;
 395                         float           tx              = tri ? fx : (1.0f-fx);
 396                         float           ty              = tri ? fy : (1.0f-fy);
 397                         const Vec4&     t0              = tri ? v00 : v11;
 398                         const Vec4&     t1              = tri ? v01 : v10;
 399                         const Vec4&     t2              = tri ? v10 : v01;
 400                         Vec4            color   = t0 + (t1-t0)*tx + (t2-t0)*ty;
 401
 402                         dstAccess.setPixel(color, x0+x, y0+y);
 403                 }
 404         }
 405 }
 406
 407 bool VertexArrayVerifier::verify (deUint32 buffer, const deUint8* refPtr, int offset, int numBytes)
 408 {
 409         const tcu::RenderTarget&        renderTarget            = m_context.getRenderContext().getRenderTarget();
 410         const int                                       numBytesInVtx           = 3;
 411         const int                                       numBytesInQuad          = numBytesInVtx*4;
 412         int                                                     maxQuadsX                       = de::min(128, renderTarget.getWidth()  / VERIFY_QUAD_SIZE);
 413         int                                                     maxQuadsY                       = de::min(128, renderTarget.getHeight() / VERIFY_QUAD_SIZE);
 414         int                                                     maxQuadsPerBatch        = maxQuadsX*maxQuadsY;
 415         int                                                     numVerified                     = 0;
 416         deUint32                                        program                         = m_program->getProgram();
 417         tcu::RGBA                                       threshold                       = renderTarget.getPixelFormat().getColorThreshold() + tcu::RGBA(4,4,4,4);
 418         bool                                            isOk                            = true;
 419
 420         vector<tcu::Vec2>                       positions;
 421         vector<deUint16>                        indices;
 422
 423         tcu::Surface                            rendered;
 424         tcu::Surface                            reference;
 425
 426         DE_ASSERT(numBytes >= numBytesInQuad); // Can't render full quad with smaller buffers.
 427
 428         computePositions(positions, maxQuadsX, maxQuadsY);
 429         computeIndices(indices, maxQuadsX, maxQuadsY);
 430
 431         // Reset buffer bindings.
 432         glBindBuffer                            (GL_ELEMENT_ARRAY_BUFFER,       0);
 433         glBindBuffer                            (GL_ARRAY_BUFFER,                       0);
 434
 435         // Setup rendering state.
 436         glViewport                                      (0, 0, maxQuadsX*VERIFY_QUAD_SIZE, maxQuadsY*VERIFY_QUAD_SIZE);
 437         glClearColor                            (0.0f, 0.0f, 0.0f, 1.0f);
 438         glUseProgram                            (program);
 439         glEnableVertexAttribArray       (m_posLoc);
 440         glVertexAttribPointer           (m_posLoc, 2, GL_FLOAT, GL_FALSE, 0, &positions[0]);
 441         glEnableVertexAttribArray       (m_byteVecLoc);
 442         glBindBuffer                            (GL_ARRAY_BUFFER, buffer);
 443
 444         while (numVerified < numBytes)
 445         {
 446                 int             numRemaining            = numBytes-numVerified;
 447                 bool    isLeftoverBatch         = numRemaining < numBytesInQuad;
 448                 int             numBytesToVerify        = isLeftoverBatch ? numBytesInQuad                              : de::min(maxQuadsPerBatch*numBytesInQuad, numRemaining - numRemaining%numBytesInQuad);
 449                 int             curOffset                       = isLeftoverBatch ? (numBytes-numBytesInQuad)   : numVerified;
 450                 int             numQuads                        = numBytesToVerify/numBytesInQuad;
 451                 int             numCols                         = de::min(maxQuadsX, numQuads);
 452                 int             numRows                         = numQuads/maxQuadsX + (numQuads%maxQuadsX != 0 ? 1 : 0);
 453                 string  imageSetDesc            = string("Bytes ") + de::toString(offset+curOffset) + " to " + de::toString(offset+curOffset+numBytesToVerify-1);
 454
 455                 DE_ASSERT(numBytesToVerify > 0 && numBytesToVerify%numBytesInQuad == 0);
 456                 DE_ASSERT(de::inBounds(curOffset, 0, numBytes));
 457                 DE_ASSERT(de::inRange(curOffset+numBytesToVerify, curOffset, numBytes));
 458
 459                 // Render batch.
 460                 glClear                                 (GL_COLOR_BUFFER_BIT);
 461                 glVertexAttribPointer   (m_byteVecLoc, 3, GL_UNSIGNED_BYTE, GL_TRUE, 0, (const glw::GLvoid*)(deUintptr)(offset + curOffset));
 462                 glDrawElements                  (GL_TRIANGLES, numQuads*6, GL_UNSIGNED_SHORT, &indices[0]);
 463
 464                 renderQuadGridReference(reference,  numQuads, numCols, refPtr + offset + curOffset);
 465
 466                 rendered.setSize(numCols*VERIFY_QUAD_SIZE, numRows*VERIFY_QUAD_SIZE);
 467                 glu::readPixels(m_context.getRenderContext(), 0, 0, rendered.getAccess());
 468
 469                 if (!tcu::pixelThresholdCompare(m_context.getTestContext().getLog(), "RenderResult", imageSetDesc.c_str(), reference, rendered, threshold, tcu::COMPARE_LOG_RESULT))
 470                 {
 471                         isOk = false;
 472                         break;
 473                 }
 474
 475                 numVerified += isLeftoverBatch ? numRemaining : numBytesToVerify;
 476         }
 477
 478         glDisableVertexAttribArray      (m_posLoc);
 479         glDisableVertexAttribArray      (m_byteVecLoc);
 480
 481         return isOk;
 482 }
 483
 484 // IndexArrayVerifier
 485
 486 IndexArrayVerifier::IndexArrayVerifier (Context& context)
 487         : BufferVerifierBase    (context)
 488         , m_program                             (DE_NULL)
 489         , m_posLoc                              (0)
 490         , m_colorLoc                    (0)
 491 {
 492         m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::makeVtxFragSources(
 493                 "attribute highp vec2 a_position;\n"
 494                 "attribute mediump vec3 a_color;\n"
 495                 "varying mediump vec3 v_color;\n"
 496                 "void main (void)\n"
 497                 "{\n"
 498                 "       gl_Position = vec4(a_position, 0.0, 1.0);\n"
 499                 "       v_color = a_color;\n"
 500                 "}\n",
 501
 502                 "varying mediump vec3 v_color;\n"
 503                 "void main (void)\n"
 504                 "{\n"
 505                 "       gl_FragColor = vec4(v_color, 1.0);\n"
 506                 "}\n"));
 507
 508         if (!m_program->isOk())
 509         {
 510                 m_context.getTestContext().getLog() << *m_program;
 511                 delete m_program;
 512                 TCU_FAIL("Compile failed");
 513         }
 514
 515         const glw::Functions& funcs = context.getRenderContext().getFunctions();
 516         m_posLoc        = funcs.getAttribLocation(m_program->getProgram(), "a_position");
 517         m_colorLoc      = funcs.getAttribLocation(m_program->getProgram(), "a_color");
 518 }
 519
 520 IndexArrayVerifier::~IndexArrayVerifier (void)
 521 {
 522         delete m_program;
 523 }
 524
 525 static void computeIndexVerifierPositions (std::vector<tcu::Vec2>& dst)
 526 {
 527         const int       numPosX         = 16;
 528         const int       numPosY         = 16;
 529
 530         dst.resize(numPosX*numPosY);
 531
 532         for (int y = 0; y < numPosY; y++)
 533         {
 534                 for (int x = 0; x < numPosX; x++)
 535                 {
 536                         float   xf      = float(x) / float(numPosX-1);
 537                         float   yf      = float(y) / float(numPosY-1);
 538
 539                         dst[y*numPosX + x] = tcu::Vec2(2.0f*xf - 1.0f, 2.0f*yf - 1.0f);
 540                 }
 541         }
 542 }
 543
 544 static void computeIndexVerifierColors (std::vector<tcu::Vec3>& dst)
 545 {
 546         const int       numColors       = 256;
 547         const float     minVal          = 0.1f;
 548         const float maxVal              = 0.5f;
 549         de::Random      rnd                     (0xabc231);
 550
 551         dst.resize(numColors);
 552
 553         for (std::vector<tcu::Vec3>::iterator i = dst.begin(); i != dst.end(); ++i)
 554         {
 555                 i->x()  = rnd.getFloat(minVal, maxVal);
 556                 i->y()  = rnd.getFloat(minVal, maxVal);
 557                 i->z()  = rnd.getFloat(minVal, maxVal);
 558         }
 559 }
 560
 561 template<typename T>
 562 static void execVertexFetch (T* dst, const T* src, const deUint8* indices, int numIndices)
 563 {
 564         for (int i = 0; i < numIndices; ++i)
 565                 dst[i] = src[indices[i]];
 566 }
 567
 568 bool IndexArrayVerifier::verify (deUint32 buffer, const deUint8* refPtr, int offset, int numBytes)
 569 {
 570         const tcu::RenderTarget&        renderTarget            = m_context.getRenderContext().getRenderTarget();
 571         const int                                       viewportW                       = de::min<int>(INDEX_ARRAY_DRAW_VIEWPORT_WIDTH, renderTarget.getWidth());
 572         const int                                       viewportH                       = de::min<int>(INDEX_ARRAY_DRAW_VIEWPORT_HEIGHT, renderTarget.getHeight());
 573         const int                                       minBytesPerBatch        = 2;
 574         const tcu::RGBA                         threshold                       (0,0,0,0);
 575
 576         std::vector<tcu::Vec2>          positions;
 577         std::vector<tcu::Vec3>          colors;
 578
 579         std::vector<tcu::Vec2>          fetchedPos                      (MAX_LINES_PER_INDEX_ARRAY_DRAW+1);
 580         std::vector<tcu::Vec3>          fetchedColor            (MAX_LINES_PER_INDEX_ARRAY_DRAW+1);
 581
 582         tcu::Surface                            indexBufferImg          (viewportW, viewportH);
 583         tcu::Surface                            referenceImg            (viewportW, viewportH);
 584
 585         int                                                     numVerified                     = 0;
 586         bool                                            isOk                            = true;
 587
 588         DE_STATIC_ASSERT(sizeof(tcu::Vec2) == sizeof(float)*2);
 589         DE_STATIC_ASSERT(sizeof(tcu::Vec3) == sizeof(float)*3);
 590
 591         computeIndexVerifierPositions(positions);
 592         computeIndexVerifierColors(colors);
 593
 594         // Reset buffer bindings.
 595         glBindBuffer                            (GL_ARRAY_BUFFER,                       0);
 596         glBindBuffer                            (GL_ELEMENT_ARRAY_BUFFER,       buffer);
 597
 598         // Setup rendering state.
 599         glViewport                                      (0, 0, viewportW, viewportH);
 600         glClearColor                            (0.0f, 0.0f, 0.0f, 1.0f);
 601         glUseProgram                            (m_program->getProgram());
 602         glEnableVertexAttribArray       (m_posLoc);
 603         glEnableVertexAttribArray       (m_colorLoc);
 604         glEnable                                        (GL_BLEND);
 605         glBlendFunc                                     (GL_ONE, GL_ONE);
 606         glBlendEquation                         (GL_FUNC_ADD);
 607
 608         while (numVerified < numBytes)
 609         {
 610                 int             numRemaining            = numBytes-numVerified;
 611                 bool    isLeftoverBatch         = numRemaining < minBytesPerBatch;
 612                 int             numBytesToVerify        = isLeftoverBatch ? minBytesPerBatch                    : de::min(MAX_LINES_PER_INDEX_ARRAY_DRAW+1, numRemaining);
 613                 int             curOffset                       = isLeftoverBatch ? (numBytes-minBytesPerBatch) : numVerified;
 614                 string  imageSetDesc            = string("Bytes ") + de::toString(offset+curOffset) + " to " + de::toString(offset+curOffset+numBytesToVerify-1);
 615
 616                 // Step 1: Render using index buffer.
 617                 glClear                                 (GL_COLOR_BUFFER_BIT);
 618                 glVertexAttribPointer   (m_posLoc, 2, GL_FLOAT, GL_FALSE, 0, &positions[0]);
 619                 glVertexAttribPointer   (m_colorLoc, 3, GL_FLOAT, GL_FALSE, 0, &colors[0]);
 620                 glDrawElements                  (GL_LINE_STRIP, numBytesToVerify, GL_UNSIGNED_BYTE, (void*)(deUintptr)(offset+curOffset));
 621                 glu::readPixels                 (m_context.getRenderContext(), 0, 0, indexBufferImg.getAccess());
 622
 623                 // Step 2: Do manual fetch and render without index buffer.
 624                 execVertexFetch(&fetchedPos[0], &positions[0], refPtr+offset+curOffset, numBytesToVerify);
 625                 execVertexFetch(&fetchedColor[0], &colors[0], refPtr+offset+curOffset, numBytesToVerify);
 626
 627                 glClear                                 (GL_COLOR_BUFFER_BIT);
 628                 glVertexAttribPointer   (m_posLoc, 2, GL_FLOAT, GL_FALSE, 0, &fetchedPos[0]);
 629                 glVertexAttribPointer   (m_colorLoc, 3, GL_FLOAT, GL_FALSE, 0, &fetchedColor[0]);
 630                 glDrawArrays                    (GL_LINE_STRIP, 0, numBytesToVerify);
 631                 glu::readPixels                 (m_context.getRenderContext(), 0, 0, referenceImg.getAccess());
 632
 633                 if (!tcu::pixelThresholdCompare(m_context.getTestContext().getLog(), "RenderResult", imageSetDesc.c_str(), referenceImg, indexBufferImg, threshold, tcu::COMPARE_LOG_RESULT))
 634                 {
 635                         isOk = false;
 636                         break;
 637                 }
 638
 639                 numVerified += isLeftoverBatch ? numRemaining : numBytesToVerify;
 640         }
 641
 642         return isOk;
 643 }
 644
 645 } // BufferTestUtil
 646 } // Functional
 647 } // gles2
 648 } // deqp