modules/gles31/functional/es31fDrawBuffersIndexedTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2015 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 Indexed blend operation tests (GL_EXT_draw_buffers_indexed)
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fDrawBuffersIndexedTests.hpp"
  25
  26 #include "gluContextInfo.hpp"
  27 #include "gluDrawUtil.hpp"
  28 #include "gluObjectWrapper.hpp"
  29 #include "gluPixelTransfer.hpp"
  30 #include "gluShaderProgram.hpp"
  31 #include "gluStrUtil.hpp"
  32 #include "gluTextureUtil.hpp"
  33
  34 #include "sglrReferenceUtils.hpp"
  35
  36 #include "rrMultisamplePixelBufferAccess.hpp"
  37 #include "rrRenderer.hpp"
  38
  39 #include "glwEnums.hpp"
  40 #include "glwFunctions.hpp"
  41
  42 #include "tcuEither.hpp"
  43 #include "tcuImageCompare.hpp"
  44 #include "tcuMaybe.hpp"
  45 #include "tcuResultCollector.hpp"
  46 #include "tcuStringTemplate.hpp"
  47 #include "tcuTestLog.hpp"
  48 #include "tcuTexture.hpp"
  49 #include "tcuTextureUtil.hpp"
  50 #include "tcuVector.hpp"
  51 #include "tcuVectorUtil.hpp"
  52 #include "tcuFloat.hpp"
  53
  54 #include "deRandom.hpp"
  55 #include "deArrayUtil.hpp"
  56 #include "deStringUtil.hpp"
  57 #include "deUniquePtr.hpp"
  58
  59 #include "deInt32.h"
  60
  61 #include <string>
  62 #include <vector>
  63 #include <map>
  64
  65 using tcu::BVec4;
  66 using tcu::Either;
  67 using tcu::IVec2;
  68 using tcu::IVec4;
  69 using tcu::Maybe;
  70 using tcu::TestLog;
  71 using tcu::TextureFormat;
  72 using tcu::TextureLevel;
  73 using tcu::UVec4;
  74 using tcu::Vec2;
  75 using tcu::Vec4;
  76 using tcu::just;
  77
  78 using std::string;
  79 using std::vector;
  80 using std::map;
  81
  82 using sglr::rr_util::mapGLBlendEquation;
  83 using sglr::rr_util::mapGLBlendFunc;
  84 using sglr::rr_util::mapGLBlendEquationAdvanced;
  85
  86 namespace deqp
  87 {
  88 namespace gles31
  89 {
  90 namespace Functional
  91 {
  92 namespace
  93 {
  94
  95 typedef deUint32 BlendEq;
  96
  97 bool isAdvancedBlendEq (BlendEq eq)
  98 {
  99         switch (eq)
 100         {
 101                 case GL_MULTIPLY:               return true;
 102                 case GL_SCREEN:                 return true;
 103                 case GL_OVERLAY:                return true;
 104                 case GL_DARKEN:                 return true;
 105                 case GL_LIGHTEN:                return true;
 106                 case GL_COLORDODGE:             return true;
 107                 case GL_COLORBURN:              return true;
 108                 case GL_HARDLIGHT:              return true;
 109                 case GL_SOFTLIGHT:              return true;
 110                 case GL_DIFFERENCE:             return true;
 111                 case GL_EXCLUSION:              return true;
 112                 case GL_HSL_HUE:                return true;
 113                 case GL_HSL_SATURATION: return true;
 114                 case GL_HSL_COLOR:              return true;
 115                 case GL_HSL_LUMINOSITY: return true;
 116                 default:
 117                         return false;
 118         }
 119 }
 120
 121 struct SeparateBlendEq
 122 {
 123         SeparateBlendEq (BlendEq rgb_, BlendEq alpha_)
 124                 : rgb   (rgb_)
 125                 , alpha (alpha_)
 126         {
 127         }
 128
 129         BlendEq rgb;
 130         BlendEq alpha;
 131 };
 132
 133 struct BlendFunc
 134 {
 135         BlendFunc (deUint32 src_, deUint32 dst_)
 136                 : src (src_)
 137                 , dst (dst_)
 138         {
 139         }
 140
 141         deUint32 src;
 142         deUint32 dst;
 143 };
 144
 145 struct SeparateBlendFunc
 146 {
 147         SeparateBlendFunc (BlendFunc rgb_, BlendFunc alpha_)
 148                 : rgb   (rgb_)
 149                 , alpha (alpha_)
 150         {
 151         }
 152
 153         BlendFunc rgb;
 154         BlendFunc alpha;
 155 };
 156
 157 typedef deUint32 DrawBuffer;
 158
 159 struct BlendState
 160 {
 161         BlendState (void) {}
 162
 163         BlendState (const Maybe<bool>&                                                                  enableBlend_,
 164                                 const Maybe<Either<BlendEq, SeparateBlendEq> >&         blendEq_,
 165                                 const Maybe<Either<BlendFunc, SeparateBlendFunc> >&     blendFunc_,
 166                                 const Maybe<BVec4>&                                                                     colorMask_)
 167                 : enableBlend   (enableBlend_)
 168                 , blendEq               (blendEq_)
 169                 , blendFunc             (blendFunc_)
 170                 , colorMask             (colorMask_)
 171         {
 172         }
 173
 174         bool isEmpty (void) const
 175         {
 176                 return (!enableBlend) && (!blendEq) && (!blendFunc) && (!colorMask);
 177         }
 178
 179         Maybe<bool>                                                                             enableBlend;
 180         Maybe<Either<BlendEq, SeparateBlendEq> >                blendEq;
 181         Maybe<Either<BlendFunc, SeparateBlendFunc> >    blendFunc;
 182         Maybe<BVec4>                                                                    colorMask;
 183 };
 184
 185 void setCommonBlendState (const glw::Functions& gl, const BlendState& blend)
 186 {
 187         if (blend.enableBlend)
 188         {
 189                 if (*blend.enableBlend)
 190                         gl.enable(GL_BLEND);
 191                 else
 192                         gl.disable(GL_BLEND);
 193         }
 194
 195         if (blend.colorMask)
 196         {
 197                 const BVec4& mask = *blend.colorMask;
 198
 199                 gl.colorMask(mask.x(), mask.y(), mask.z(), mask.w());
 200         }
 201
 202         if (blend.blendEq)
 203         {
 204                 const Either<BlendEq, SeparateBlendEq>& blendEq = *blend.blendEq;
 205
 206                 if (blendEq.is<BlendEq>())
 207                         gl.blendEquation(blendEq.get<BlendEq>());
 208                 else if (blendEq.is<SeparateBlendEq>())
 209                         gl.blendEquationSeparate(blendEq.get<SeparateBlendEq>().rgb, blendEq.get<SeparateBlendEq>().alpha);
 210                 else
 211                         DE_ASSERT(false);
 212         }
 213
 214         if (blend.blendFunc)
 215         {
 216                 const Either<BlendFunc, SeparateBlendFunc>& blendFunc = *blend.blendFunc;
 217
 218                 if (blendFunc.is<BlendFunc>())
 219                         gl.blendFunc(blendFunc.get<BlendFunc>().src, blendFunc.get<BlendFunc>().dst);
 220                 else if (blendFunc.is<SeparateBlendFunc>())
 221                         gl.blendFuncSeparate(blendFunc.get<SeparateBlendFunc>().rgb.src, blendFunc.get<SeparateBlendFunc>().rgb.dst, blendFunc.get<SeparateBlendFunc>().alpha.src, blendFunc.get<SeparateBlendFunc>().alpha.dst);
 222                 else
 223                         DE_ASSERT(false);
 224         }
 225
 226         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set common blend state.");
 227 }
 228
 229 void setIndexedBlendState (const glw::Functions& gl, const BlendState& blend, deUint32 index)
 230 {
 231         if (blend.enableBlend)
 232         {
 233                 if (*blend.enableBlend)
 234                         gl.enablei(GL_BLEND, index);
 235                 else
 236                         gl.disablei(GL_BLEND, index);
 237         }
 238
 239         if (blend.colorMask)
 240         {
 241                 const BVec4 mask = *blend.colorMask;
 242
 243                 gl.colorMaski(index, mask.x(), mask.y(), mask.z(), mask.w());
 244         }
 245
 246         if (blend.blendEq)
 247         {
 248                 const Either<BlendEq, SeparateBlendEq>& blendEq = *blend.blendEq;
 249
 250                 if (blendEq.is<BlendEq>())
 251                         gl.blendEquationi(index, blendEq.get<BlendEq>());
 252                 else if (blendEq.is<SeparateBlendEq>())
 253                         gl.blendEquationSeparatei(index, blendEq.get<SeparateBlendEq>().rgb, blendEq.get<SeparateBlendEq>().alpha);
 254                 else
 255                         DE_ASSERT(false);
 256         }
 257
 258         if (blend.blendFunc)
 259         {
 260                 const Either<BlendFunc, SeparateBlendFunc>& blendFunc = *blend.blendFunc;
 261
 262                 if (blendFunc.is<BlendFunc>())
 263                         gl.blendFunci(index, blendFunc.get<BlendFunc>().src, blendFunc.get<BlendFunc>().dst);
 264                 else if (blendFunc.is<SeparateBlendFunc>())
 265                         gl.blendFuncSeparatei(index, blendFunc.get<SeparateBlendFunc>().rgb.src, blendFunc.get<SeparateBlendFunc>().rgb.dst, blendFunc.get<SeparateBlendFunc>().alpha.src, blendFunc.get<SeparateBlendFunc>().alpha.dst);
 266                 else
 267                         DE_ASSERT(false);
 268         }
 269
 270         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to set draw buffer specifig blend state.");
 271 }
 272
 273 class DrawBufferInfo
 274 {
 275 public:
 276                                                         DrawBufferInfo  (bool                                   render,
 277                                                                                          const IVec2&                   size,
 278                                                                                          const BlendState&              blendState,
 279                                                                                          const TextureFormat&   format);
 280
 281         const TextureFormat&    getFormat               (void) const { return m_format;         }
 282         const IVec2&                    getSize                 (void) const { return m_size;           }
 283         const BlendState&               getBlendState   (void) const { return m_blendState;     }
 284         bool                                    getRender               (void) const { return m_render;         }
 285
 286 private:
 287         bool                                    m_render;
 288         IVec2                                   m_size;
 289         TextureFormat                   m_format;
 290         BlendState                              m_blendState;
 291 };
 292
 293 DrawBufferInfo::DrawBufferInfo (bool render, const IVec2& size, const BlendState& blendState, const TextureFormat& format)
 294         : m_render              (render)
 295         , m_size                (size)
 296         , m_format              (format)
 297         , m_blendState  (blendState)
 298 {
 299 }
 300
 301 void clearRenderbuffer (const glw::Functions&                   gl,
 302                                                 const tcu::TextureFormat&               format,
 303                                                 int                                                             renderbufferNdx,
 304                                                 int                                                             renderbufferCount,
 305                                                 tcu::TextureLevel&                              refRenderbuffer)
 306 {
 307         const tcu::TextureFormatInfo    info            = tcu::getTextureFormatInfo(format);
 308
 309         // Clear each buffer to different color
 310         const float                                             redScale        = float(renderbufferNdx + 1) / float(renderbufferCount);
 311         const float                                             blueScale       = float(renderbufferCount - renderbufferNdx) / float(renderbufferCount);
 312         const float                                             greenScale      = float(((renderbufferCount/2) + renderbufferNdx) % renderbufferCount) / float(renderbufferCount);
 313         // Alpha should never be zero as advanced blend equations assume premultiplied alpha.
 314         const float                                             alphaScale      = float(1 + (((renderbufferCount/2) + renderbufferCount - renderbufferNdx) % renderbufferCount)) / float(renderbufferCount);
 315
 316         switch (tcu::getTextureChannelClass(format.type))
 317         {
 318                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 319                 {
 320                         const float red         = -1000.0f + 2000.0f * redScale;
 321                         const float green       = -1000.0f + 2000.0f * greenScale;
 322                         const float blue        = -1000.0f + 2000.0f * blueScale;
 323                         const float alpha       = -1000.0f + 2000.0f * alphaScale;
 324                         const Vec4      color   (red, green, blue, alpha);
 325
 326                         tcu::clear(refRenderbuffer, color);
 327                         gl.clearBufferfv(GL_COLOR, renderbufferNdx, color.getPtr());
 328                         break;
 329                 }
 330
 331                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 332                 {
 333                         const deInt32   red             = deInt32(info.valueMin.x() + (info.valueMax.x() - info.valueMin.x()) * redScale);
 334                         const deInt32   green   = deInt32(info.valueMin.y() + (info.valueMax.y() - info.valueMin.y()) * greenScale);
 335                         const deInt32   blue    = deInt32(info.valueMin.z() + (info.valueMax.z() - info.valueMin.z()) * blueScale);
 336                         const deInt32   alpha   = deInt32(info.valueMin.w() + (info.valueMax.w() - info.valueMin.w()) * alphaScale);
 337                         const IVec4             color   (red, green, blue, alpha);
 338
 339                         tcu::clear(refRenderbuffer, color);
 340                         gl.clearBufferiv(GL_COLOR, renderbufferNdx, color.getPtr());
 341                         break;
 342                 }
 343
 344                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 345                 {
 346                         const deUint32  red             = deUint32(info.valueMax.x() * redScale);
 347                         const deUint32  green   = deUint32(info.valueMax.y() * greenScale);
 348                         const deUint32  blue    = deUint32(info.valueMax.z() * blueScale);
 349                         const deUint32  alpha   = deUint32(info.valueMax.w() * alphaScale);
 350                         const UVec4             color   (red, green, blue, alpha);
 351
 352                         tcu::clear(refRenderbuffer, color);
 353                         gl.clearBufferuiv(GL_COLOR, renderbufferNdx, color.getPtr());
 354                         break;
 355                 }
 356
 357                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 358                 {
 359                         const float red         = info.valueMin.x() + (info.valueMax.x() - info.valueMin.x()) * redScale;
 360                         const float green       = info.valueMin.y() + (info.valueMax.y() - info.valueMin.y()) * greenScale;
 361                         const float blue        = info.valueMin.z() + (info.valueMax.z() - info.valueMin.z()) * blueScale;
 362                         const float alpha       = info.valueMin.w() + (info.valueMax.w() - info.valueMin.w()) * alphaScale;
 363                         const Vec4      color   (red, green, blue, alpha);
 364
 365                         tcu::clear(refRenderbuffer, color);
 366                         gl.clearBufferfv(GL_COLOR, renderbufferNdx, color.getPtr());
 367                         break;
 368                 }
 369
 370                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 371                 {
 372                         const float red         = info.valueMax.x() * redScale;
 373                         const float green       = info.valueMax.y() * greenScale;
 374                         const float blue        = info.valueMax.z() * blueScale;
 375                         const float alpha       = info.valueMax.w() * alphaScale;
 376                         const Vec4      color   (red, green, blue, alpha);
 377
 378                         tcu::clear(refRenderbuffer, color);
 379                         gl.clearBufferfv(GL_COLOR, renderbufferNdx, color.getPtr());
 380                         break;
 381                 }
 382
 383                 default:
 384                         DE_ASSERT(DE_FALSE);
 385         }
 386
 387         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to clear renderbuffer.");
 388 }
 389
 390 void genRenderbuffers (const glw::Functions&                    gl,
 391                                                 const vector<DrawBufferInfo>&   drawBuffers,
 392                                                 const glu::Framebuffer&                 framebuffer,
 393                                                 const glu::RenderbufferVector&  renderbuffers,
 394                                                 vector<TextureLevel>&                   refRenderbuffers)
 395 {
 396         vector<deUint32> bufs;
 397
 398         bufs.resize(drawBuffers.size());
 399
 400         DE_ASSERT(drawBuffers.size() == renderbuffers.size());
 401         DE_ASSERT(drawBuffers.size() == refRenderbuffers.size());
 402
 403         gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer);
 404
 405         for (int renderbufferNdx = 0; renderbufferNdx < (int)drawBuffers.size(); renderbufferNdx++)
 406         {
 407                 const DrawBufferInfo&           drawBuffer      = drawBuffers[renderbufferNdx];
 408                 const TextureFormat&            format          = drawBuffer.getFormat();
 409                 const IVec2&                            size            = drawBuffer.getSize();
 410                 const deUint32                          glFormat        = glu::getInternalFormat(format);
 411
 412                 bufs[renderbufferNdx]                                   = GL_COLOR_ATTACHMENT0 + renderbufferNdx;
 413                 refRenderbuffers[renderbufferNdx]               = TextureLevel(drawBuffer.getFormat(), size.x(), size.y());
 414
 415                 gl.bindRenderbuffer(GL_RENDERBUFFER, renderbuffers[renderbufferNdx]);
 416                 gl.renderbufferStorage(GL_RENDERBUFFER, glFormat, size.x(), size.y());
 417                 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0 + renderbufferNdx, GL_RENDERBUFFER, renderbuffers[renderbufferNdx]);
 418                 GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to create renderbuffer.");
 419         }
 420
 421         gl.drawBuffers((glw::GLsizei)bufs.size(), &(bufs[0]));
 422
 423         for (int renderbufferNdx = 0; renderbufferNdx < (int)drawBuffers.size(); renderbufferNdx++)
 424         {
 425                 const DrawBufferInfo&           drawBuffer      = drawBuffers[renderbufferNdx];
 426                 const TextureFormat&            format          = drawBuffer.getFormat();
 427
 428                 clearRenderbuffer(gl, format, renderbufferNdx, (int)refRenderbuffers.size(),  refRenderbuffers[renderbufferNdx]);
 429         }
 430
 431         gl.bindRenderbuffer(GL_RENDERBUFFER, 0);
 432         gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
 433 }
 434
 435 Vec4 getFixedPointFormatThreshold (const tcu::TextureFormat& sourceFormat, const tcu::TextureFormat& readPixelsFormat)
 436 {
 437         DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT);
 438         DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT);
 439
 440         DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER);
 441         DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER);
 442
 443         DE_ASSERT(tcu::getTextureChannelClass(sourceFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER);
 444         DE_ASSERT(tcu::getTextureChannelClass(readPixelsFormat.type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER);
 445
 446         const tcu::IVec4        srcBits         = tcu::getTextureFormatBitDepth(sourceFormat);
 447         const tcu::IVec4        readBits        = tcu::getTextureFormatBitDepth(readPixelsFormat);
 448
 449         return Vec4(3.0f) / ((tcu::Vector<deUint64, 4>(1) << (tcu::min(srcBits, readBits).cast<deUint64>())) - tcu::Vector<deUint64, 4>(1)).cast<float>();
 450 }
 451
 452 UVec4 getFloatULPThreshold (const tcu::TextureFormat& sourceFormat, const tcu::TextureFormat& readPixelsFormat)
 453 {
 454         const tcu::IVec4        srcMantissaBits         = tcu::getTextureFormatMantissaBitDepth(sourceFormat);
 455         const tcu::IVec4        readMantissaBits        = tcu::getTextureFormatMantissaBitDepth(readPixelsFormat);
 456         tcu::IVec4                      ULPDiff(0);
 457
 458         for (int i = 0; i < 4; i++)
 459                 if (readMantissaBits[i] >= srcMantissaBits[i])
 460                         ULPDiff[i] = readMantissaBits[i] - srcMantissaBits[i];
 461
 462         return UVec4(4) * (UVec4(1) << (ULPDiff.cast<deUint32>()));
 463 }
 464
 465 void verifyRenderbuffer (TestLog&                                       log,
 466                                                  tcu::ResultCollector&          results,
 467                                                  const tcu::TextureFormat&      format,
 468                                                  int                                            renderbufferNdx,
 469                                                  const tcu::TextureLevel&       refRenderbuffer,
 470                                                  const tcu::TextureLevel&       result)
 471 {
 472         switch (tcu::getTextureChannelClass(format.type))
 473         {
 474                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 475                 {
 476                         const string    name            = "Renderbuffer" + de::toString(renderbufferNdx);
 477                         const string    desc            = "Compare renderbuffer " + de::toString(renderbufferNdx);
 478                         const UVec4             threshold       = getFloatULPThreshold(format, result.getFormat());
 479
 480                         if (!tcu::floatUlpThresholdCompare(log, name.c_str(), desc.c_str(), refRenderbuffer, result, threshold, tcu::COMPARE_LOG_RESULT))
 481                                 results.fail("Verification of renderbuffer " + de::toString(renderbufferNdx) + " failed.");
 482
 483                         break;
 484                 }
 485
 486                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 487                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 488                 {
 489                         const string    name            = "Renderbuffer" + de::toString(renderbufferNdx);
 490                         const string    desc            = "Compare renderbuffer " + de::toString(renderbufferNdx);
 491                         const UVec4             threshold       (1, 1, 1, 1);
 492
 493                         if (!tcu::intThresholdCompare(log, name.c_str(), desc.c_str(), refRenderbuffer, result, threshold, tcu::COMPARE_LOG_RESULT))
 494                                 results.fail("Verification of renderbuffer " + de::toString(renderbufferNdx) + " failed.");
 495
 496                         break;
 497                 }
 498
 499                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 500                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 501                 {
 502                         const string    name            = "Renderbuffer" + de::toString(renderbufferNdx);
 503                         const string    desc            = "Compare renderbuffer " + de::toString(renderbufferNdx);
 504                         const Vec4              threshold       = getFixedPointFormatThreshold(format, result.getFormat());
 505
 506                         if (!tcu::floatThresholdCompare(log, name.c_str(), desc.c_str(), refRenderbuffer, result, threshold, tcu::COMPARE_LOG_RESULT))
 507                                 results.fail("Verification of renderbuffer " + de::toString(renderbufferNdx) + " failed.");
 508
 509                         break;
 510                 }
 511
 512                 default:
 513                         DE_ASSERT(DE_FALSE);
 514         }
 515 }
 516
 517 TextureFormat getReadPixelFormat (const TextureFormat& format)
 518 {
 519         switch (tcu::getTextureChannelClass(format.type))
 520         {
 521                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 522                         return TextureFormat(TextureFormat::RGBA, TextureFormat::UNSIGNED_INT32);
 523
 524                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 525                         return TextureFormat(TextureFormat::RGBA, TextureFormat::SIGNED_INT32);
 526
 527                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 528                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 529                         return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
 530
 531                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 532                         return TextureFormat(TextureFormat::RGBA, TextureFormat::FLOAT);
 533
 534                 default:
 535                         DE_ASSERT(false);
 536                         return TextureFormat(TextureFormat::RGBA, TextureFormat::UNORM_INT8);
 537         }
 538 }
 539
 540 void verifyRenderbuffers (TestLog&                                                      log,
 541                                                         tcu::ResultCollector&                           results,
 542                                                         glu::RenderContext&                             renderContext,
 543                                                         const glu::RenderbufferVector&  renderbuffers,
 544                                                         const glu::Framebuffer&                 framebuffer,
 545                                                         const vector<TextureLevel>&             refRenderbuffers)
 546 {
 547         const glw::Functions& gl = renderContext.getFunctions();
 548
 549         DE_ASSERT(renderbuffers.size() == refRenderbuffers.size());
 550
 551         gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer);
 552
 553         for (int renderbufferNdx = 0; renderbufferNdx < (int)renderbuffers.size(); renderbufferNdx++)
 554         {
 555                 const TextureLevel&     refRenderbuffer = refRenderbuffers[renderbufferNdx];
 556                 const int                       width                   = refRenderbuffer.getWidth();
 557                 const int                       height                  = refRenderbuffer.getHeight();
 558                 const TextureFormat     format                  = refRenderbuffer.getFormat();
 559
 560                 tcu::TextureLevel       result                  (getReadPixelFormat(format), width, height);
 561
 562                 gl.readBuffer(GL_COLOR_ATTACHMENT0 + renderbufferNdx);
 563                 glu::readPixels(renderContext, 0, 0, result.getAccess());
 564                 GLU_EXPECT_NO_ERROR(gl.getError(), "Reading pixels from renderbuffer failed.");
 565
 566                 verifyRenderbuffer(log, results, format, renderbufferNdx, refRenderbuffer, result);
 567         }
 568
 569         gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
 570 }
 571
 572 static const float s_quadCoords[] =
 573 {
 574         -0.5f, -0.5f,
 575          0.5f, -0.5f,
 576          0.5f,  0.5f,
 577
 578          0.5f,  0.5f,
 579         -0.5f,  0.5f,
 580         -0.5f, -0.5f
 581 };
 582
 583 void setBlendState (rr::FragmentOperationState& fragOps, const BlendState& state)
 584 {
 585         if (state.blendEq)
 586         {
 587                 if (state.blendEq->is<BlendEq>())
 588                 {
 589                         if (isAdvancedBlendEq(state.blendEq->get<BlendEq>()))
 590                         {
 591                                 const rr::BlendEquationAdvanced equation = mapGLBlendEquationAdvanced(state.blendEq->get<BlendEq>());
 592
 593                                 fragOps.blendMode                               = rr::BLENDMODE_ADVANCED;
 594                                 fragOps.blendEquationAdvaced    = equation;
 595                         }
 596                         else
 597                         {
 598                                 const rr::BlendEquation equation = mapGLBlendEquation(state.blendEq->get<BlendEq>());
 599
 600                                 fragOps.blendMode                               = rr::BLENDMODE_STANDARD;
 601                                 fragOps.blendRGBState.equation  = equation;
 602                                 fragOps.blendAState.equation    = equation;
 603                         }
 604                 }
 605                 else
 606                 {
 607                         DE_ASSERT(state.blendEq->is<SeparateBlendEq>());
 608
 609                         fragOps.blendMode                               = rr::BLENDMODE_STANDARD;
 610                         fragOps.blendRGBState.equation  = mapGLBlendEquation(state.blendEq->get<SeparateBlendEq>().rgb);
 611                         fragOps.blendAState.equation    = mapGLBlendEquation(state.blendEq->get<SeparateBlendEq>().alpha);
 612                 }
 613         }
 614
 615         if (state.blendFunc)
 616         {
 617                 if (state.blendFunc->is<BlendFunc>())
 618                 {
 619                         const rr::BlendFunc srcFunction = mapGLBlendFunc(state.blendFunc->get<BlendFunc>().src);
 620                         const rr::BlendFunc dstFunction = mapGLBlendFunc(state.blendFunc->get<BlendFunc>().dst);
 621
 622                         fragOps.blendRGBState.srcFunc   = srcFunction;
 623                         fragOps.blendRGBState.dstFunc   = dstFunction;
 624
 625                         fragOps.blendAState.srcFunc             = srcFunction;
 626                         fragOps.blendAState.dstFunc             = dstFunction;
 627                 }
 628                 else
 629                 {
 630                         DE_ASSERT(state.blendFunc->is<SeparateBlendFunc>());
 631
 632                         fragOps.blendRGBState.srcFunc   = mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().rgb.src);
 633                         fragOps.blendRGBState.dstFunc   = mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().rgb.dst);
 634
 635                         fragOps.blendAState.srcFunc             = mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().alpha.src);
 636                         fragOps.blendAState.dstFunc             = mapGLBlendFunc(state.blendFunc->get<SeparateBlendFunc>().alpha.dst);
 637                 }
 638         }
 639
 640         if (state.colorMask)
 641                 fragOps.colorMask = *state.colorMask;
 642 }
 643
 644 rr::RenderState createRenderState (const BlendState& preCommonBlendState, const BlendState& postCommonBlendState, const DrawBufferInfo& info)
 645 {
 646         const IVec2             size    = info.getSize();
 647         rr::RenderState state   (rr::ViewportState(rr::WindowRectangle(0, 0, size.x(), size.y())));
 648
 649         state.fragOps.blendMode = rr::BLENDMODE_STANDARD;
 650
 651         setBlendState(state.fragOps, preCommonBlendState);
 652         setBlendState(state.fragOps, info.getBlendState());
 653         setBlendState(state.fragOps, postCommonBlendState);
 654
 655         if (postCommonBlendState.enableBlend)
 656                 state.fragOps.blendMode = (*(postCommonBlendState.enableBlend) ? state.fragOps.blendMode : rr::BLENDMODE_NONE);
 657         else  if (info.getBlendState().enableBlend)
 658                 state.fragOps.blendMode = (*(info.getBlendState().enableBlend) ? state.fragOps.blendMode : rr::BLENDMODE_NONE);
 659         else if (preCommonBlendState.enableBlend)
 660                 state.fragOps.blendMode = (*(preCommonBlendState.enableBlend) ? state.fragOps.blendMode : rr::BLENDMODE_NONE);
 661         else
 662                 state.fragOps.blendMode = rr::BLENDMODE_NONE;
 663
 664         if (tcu::getTextureChannelClass(info.getFormat().type) != tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT
 665                 && tcu::getTextureChannelClass(info.getFormat().type) != tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT
 666                 && tcu::getTextureChannelClass(info.getFormat().type) != tcu::TEXTURECHANNELCLASS_FLOATING_POINT)
 667                 state.fragOps.blendMode = rr::BLENDMODE_NONE;
 668
 669         return state;
 670 }
 671
 672 class VertexShader : public rr::VertexShader
 673 {
 674 public:
 675                                         VertexShader    (void);
 676         virtual void    shadeVertices   (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const;
 677 };
 678
 679 VertexShader::VertexShader (void)
 680         : rr::VertexShader      (1, 1)
 681 {
 682         m_inputs[0].type        = rr::GENERICVECTYPE_FLOAT;
 683         m_outputs[0].type       = rr::GENERICVECTYPE_FLOAT;
 684 }
 685
 686 void VertexShader::shadeVertices (const rr::VertexAttrib* inputs, rr::VertexPacket* const* packets, const int numPackets) const
 687 {
 688         for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
 689         {
 690                 rr::VertexPacket& packet = *packets[packetNdx];
 691
 692                 packet.position         = rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx);
 693                 packet.outputs[0]       = 0.5f * (Vec4(1.0f) + rr::readVertexAttribFloat(inputs[0], packet.instanceNdx, packet.vertexNdx));
 694         }
 695 }
 696
 697 class FragmentShader : public rr::FragmentShader
 698 {
 699 public:
 700                         FragmentShader  (int drawBufferNdx, const DrawBufferInfo& info);
 701         void    shadeFragments  (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const;
 702
 703 private:
 704         const int                               m_drawBufferNdx;
 705         const DrawBufferInfo    m_info;
 706 };
 707
 708 FragmentShader::FragmentShader (int drawBufferNdx, const DrawBufferInfo& info)
 709         : rr::FragmentShader    (1, 1)
 710         , m_drawBufferNdx               (drawBufferNdx)
 711         , m_info                                (info)
 712 {
 713         m_inputs[0].type = rr::GENERICVECTYPE_FLOAT;
 714
 715         switch (tcu::getTextureChannelClass(m_info.getFormat().type))
 716         {
 717                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 718                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 719                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 720                         m_outputs[0].type = rr::GENERICVECTYPE_FLOAT;
 721                         break;
 722
 723                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 724                         m_outputs[0].type = rr::GENERICVECTYPE_UINT32;
 725                         break;
 726
 727                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 728                         m_outputs[0].type = rr::GENERICVECTYPE_INT32;
 729                         break;
 730
 731                 default:
 732                         DE_ASSERT(false);
 733         };
 734 }
 735
 736 void FragmentShader::shadeFragments (rr::FragmentPacket* packets, const int numPackets, const rr::FragmentShadingContext& context) const
 737 {
 738         for (int packetNdx = 0; packetNdx < numPackets; ++packetNdx)
 739         {
 740                 rr::FragmentPacket& packet = packets[packetNdx];
 741
 742                 DE_ASSERT(m_drawBufferNdx >= 0);
 743                 DE_UNREF(m_info);
 744
 745                 for (int fragNdx = 0; fragNdx < 4; ++fragNdx)
 746                 {
 747                         const Vec2      vColor          = rr::readVarying<float>(packet, context, 0, fragNdx).xy();
 748                         const float     values[]        =
 749                         {
 750                                 vColor.x(),
 751                                 vColor.y(),
 752                                 (1.0f - vColor.x()),
 753                                 (1.0f - vColor.y())
 754                         };
 755
 756                         switch (tcu::getTextureChannelClass(m_info.getFormat().type))
 757                         {
 758                                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 759                                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 760                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 761                                 {
 762                                         const Vec4 color (values[(m_drawBufferNdx + 0) % 4],
 763                                                                           values[(m_drawBufferNdx + 1) % 4],
 764                                                                           values[(m_drawBufferNdx + 2) % 4],
 765                                                                           values[(m_drawBufferNdx + 3) % 4]);
 766
 767                                         rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
 768                                         break;
 769                                 }
 770
 771                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 772                                 {
 773                                         const UVec4 color ((deUint32)(values[(m_drawBufferNdx + 0) % 4]),
 774                                                                            (deUint32)(values[(m_drawBufferNdx + 1) % 4]),
 775                                                                            (deUint32)(values[(m_drawBufferNdx + 2) % 4]),
 776                                                                            (deUint32)(values[(m_drawBufferNdx + 3) % 4]));
 777
 778                                         rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
 779                                         break;
 780                                 }
 781
 782                                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 783                                 {
 784                                         const IVec4 color ((deInt32)(values[(m_drawBufferNdx + 0) % 4]),
 785                                                                            (deInt32)(values[(m_drawBufferNdx + 1) % 4]),
 786                                                                            (deInt32)(values[(m_drawBufferNdx + 2) % 4]),
 787                                                                            (deInt32)(values[(m_drawBufferNdx + 3) % 4]));
 788
 789                                         rr::writeFragmentOutput(context, packetNdx, fragNdx, 0, color);
 790                                         break;
 791                                 }
 792
 793                                 default:
 794                                         DE_ASSERT(DE_FALSE);
 795                         };
 796                 }
 797         }
 798 }
 799
 800 rr::VertexAttrib createVertexAttrib (const float* coords)
 801 {
 802         rr::VertexAttrib attrib;
 803
 804         attrib.type             = rr::VERTEXATTRIBTYPE_FLOAT;
 805         attrib.size             = 2;
 806         attrib.pointer  = coords;
 807
 808         return attrib;
 809 }
 810
 811 void renderRefQuad (const BlendState&                           preCommonBlendState,
 812                                         const BlendState&                               postCommonBlendState,
 813                                         const vector<DrawBufferInfo>&   drawBuffers,
 814                                         vector<TextureLevel>&                   refRenderbuffers)
 815 {
 816         const rr::Renderer                      renderer;
 817         const rr::PrimitiveList         primitives              (rr::PRIMITIVETYPE_TRIANGLES, 6, 0);
 818         const rr::VertexAttrib          vertexAttribs[] =
 819         {
 820                 createVertexAttrib(s_quadCoords)
 821         };
 822
 823         for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
 824         {
 825                 if (drawBuffers[drawBufferNdx].getRender())
 826                 {
 827                         const rr::RenderState   renderState             (createRenderState(preCommonBlendState, postCommonBlendState, drawBuffers[drawBufferNdx]));
 828                         const rr::RenderTarget  renderTarget    (rr::MultisamplePixelBufferAccess::fromSinglesampleAccess(refRenderbuffers[drawBufferNdx].getAccess()));
 829                         const VertexShader              vertexShader;
 830                         const FragmentShader    fragmentShader  (drawBufferNdx, drawBuffers[drawBufferNdx]);
 831                         const rr::Program               program                 (&vertexShader, &fragmentShader);
 832                         const rr::DrawCommand   command                 (renderState, renderTarget, program, DE_LENGTH_OF_ARRAY(vertexAttribs), vertexAttribs, primitives);
 833
 834                         renderer.draw(command);
 835                 }
 836         }
 837 }
 838
 839 bool requiresAdvancedBlendEq (const BlendState& pre, const BlendState post, const vector<DrawBufferInfo>& drawBuffers)
 840 {
 841         bool requiresAdvancedBlendEq = false;
 842
 843         if (pre.blendEq && pre.blendEq->is<BlendEq>())
 844                 requiresAdvancedBlendEq |= isAdvancedBlendEq(pre.blendEq->get<BlendEq>());
 845
 846         if (post.blendEq && post.blendEq->is<BlendEq>())
 847                 requiresAdvancedBlendEq |= isAdvancedBlendEq(post.blendEq->get<BlendEq>());
 848
 849         for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
 850         {
 851                 const BlendState& drawBufferBlendState = drawBuffers[drawBufferNdx].getBlendState();
 852
 853                 if (drawBufferBlendState.blendEq && drawBufferBlendState.blendEq->is<BlendEq>())
 854                         requiresAdvancedBlendEq |= isAdvancedBlendEq(drawBufferBlendState.blendEq->get<BlendEq>());
 855         }
 856
 857         return requiresAdvancedBlendEq;
 858 }
 859
 860 glu::VertexSource genVertexSource (glu::RenderContext& renderContext)
 861 {
 862         const bool supportsES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
 863
 864         const char* const vertexSource =
 865                 "${GLSL_VERSION_DECL}\n"
 866                 "layout(location=0) in highp vec2 i_coord;\n"
 867                 "out highp vec2 v_color;\n"
 868                 "void main (void)\n"
 869                 "{\n"
 870                 "\tv_color = 0.5 * (vec2(1.0) + i_coord);\n"
 871                 "\tgl_Position = vec4(i_coord, 0.0, 1.0);\n"
 872                 "}";
 873
 874         map<string, string> args;
 875         args["GLSL_VERSION_DECL"] = supportsES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 876
 877         return glu::VertexSource(tcu::StringTemplate(vertexSource).specialize(args));
 878 }
 879
 880 glu::FragmentSource genFragmentSource (const BlendState& preCommonBlendState, const BlendState& postCommonBlendState, const vector<DrawBufferInfo>& drawBuffers, glu::RenderContext& renderContext)
 881 {
 882         std::ostringstream stream;
 883         const bool supportsES32 = glu::contextSupports(renderContext.getType(), glu::ApiType::es(3, 2));
 884
 885         stream << "${GLSL_VERSION_DECL}\n";
 886
 887         if (requiresAdvancedBlendEq(preCommonBlendState, postCommonBlendState, drawBuffers))
 888         {
 889                 stream << "${GLSL_EXTENSION}"
 890                            <<  "layout(blend_support_all_equations) out;\n";
 891         }
 892
 893         stream << "in highp vec2 v_color;\n";
 894
 895         for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
 896         {
 897                 const DrawBufferInfo&   drawBuffer                      = drawBuffers[drawBufferNdx];
 898                 const TextureFormat&    format                          = drawBuffer.getFormat();
 899
 900                 stream << "layout(location=" << drawBufferNdx << ") out highp ";
 901
 902                 switch (tcu::getTextureChannelClass(format.type))
 903                 {
 904                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 905                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 906                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 907                                 stream << "vec4";
 908                                 break;
 909
 910                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 911                                 stream << "uvec4";
 912                                 break;
 913
 914                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 915                                 stream << "ivec4";
 916                                 break;
 917
 918                         default:
 919                                 DE_ASSERT(DE_FALSE);
 920                 };
 921
 922                 stream << " o_drawBuffer" <<  drawBufferNdx << ";\n";
 923         }
 924
 925         stream << "void main (void)\n"
 926                    << "{\n";
 927
 928         for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
 929         {
 930                 const DrawBufferInfo&   drawBuffer              = drawBuffers[drawBufferNdx];
 931                 const TextureFormat&    format                  = drawBuffer.getFormat();
 932                 const char* const               values[]                =
 933                 {
 934                         "v_color.x",
 935                         "v_color.y",
 936                         "(1.0 - v_color.x)",
 937                         "(1.0 - v_color.y)"
 938                 };
 939
 940                 stream << "\to_drawBuffer" <<  drawBufferNdx;
 941
 942                 switch (tcu::getTextureChannelClass(format.type))
 943                 {
 944                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 945                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 946                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 947                                 stream << " = vec4(" << values[(drawBufferNdx + 0) % 4]
 948                                            << ", " << values[(drawBufferNdx + 1) % 4]
 949                                            << ", " << values[(drawBufferNdx + 2) % 4]
 950                                            << ", " << values[(drawBufferNdx + 3) % 4] << ");\n";
 951                                 break;
 952
 953                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 954                                 stream << " = uvec4(uint(" << values[(drawBufferNdx + 0) % 4]
 955                                            << "), uint(" << values[(drawBufferNdx + 1) % 4]
 956                                            << "), uint(" << values[(drawBufferNdx + 2) % 4]
 957                                            << "), uint(" << values[(drawBufferNdx + 3) % 4] << "));\n";
 958                                 break;
 959
 960                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 961                                 stream << " = ivec4(int(" << values[(drawBufferNdx + 0) % 4]
 962                                            << "), int(" << values[(drawBufferNdx + 1) % 4]
 963                                            << "), int(" << values[(drawBufferNdx + 2) % 4]
 964                                            << "), int(" << values[(drawBufferNdx + 3) % 4] << "));\n";
 965                                 break;
 966
 967                         default:
 968                                 DE_ASSERT(DE_FALSE);
 969                 };
 970         }
 971
 972         stream << "}";
 973
 974         map<string, string> args;
 975         args["GLSL_VERSION_DECL"] = supportsES32 ? getGLSLVersionDeclaration(glu::GLSL_VERSION_320_ES) : getGLSLVersionDeclaration(glu::GLSL_VERSION_310_ES);
 976         args["GLSL_EXTENSION"] = supportsES32 ? "\n" : "#extension GL_KHR_blend_equation_advanced : require\n";
 977
 978         return glu::FragmentSource(tcu::StringTemplate(stream.str()).specialize(args));
 979 }
 980
 981 glu::ProgramSources genShaderSources (const BlendState& preCommonBlendState, const BlendState& postCommonBlendState, const vector<DrawBufferInfo>& drawBuffers, glu::RenderContext& renderContext)
 982 {
 983         return glu::ProgramSources() << genVertexSource(renderContext) << genFragmentSource(preCommonBlendState, postCommonBlendState, drawBuffers, renderContext);
 984 }
 985
 986 void renderGLQuad (glu::RenderContext&                  renderContext,
 987                                    const glu::ShaderProgram&    program)
 988 {
 989         const glu::VertexArrayBinding vertexArrays[] =
 990         {
 991                 glu::VertexArrayBinding(glu::BindingPoint(0), glu::VertexArrayPointer(glu::VTX_COMP_FLOAT, glu::VTX_COMP_CONVERT_NONE, 2, 6, 0, s_quadCoords))
 992         };
 993
 994         glu::draw(renderContext, program.getProgram(), 1, vertexArrays, glu::pr::Triangles(6));
 995 }
 996
 997 void renderQuad (TestLog&                                               log,
 998                                  glu::RenderContext&                    renderContext,
 999                                  const BlendState&                              preCommonBlendState,
1000                                  const BlendState&                              postCommonBlendState,
1001                                  const vector<DrawBufferInfo>&  drawBuffers,
1002                                  const glu::Framebuffer&                framebuffer,
1003                                  vector<TextureLevel>&                  refRenderbuffers)
1004 {
1005         const glw::Functions&           gl                                              = renderContext.getFunctions();
1006         const glu::ShaderProgram        program                                 (gl, genShaderSources(preCommonBlendState, postCommonBlendState, drawBuffers, renderContext));
1007         const IVec2                                     size                                    = drawBuffers[0].getSize();
1008         const bool                                      requiresBlendBarriers   = requiresAdvancedBlendEq(preCommonBlendState, postCommonBlendState, drawBuffers);
1009
1010         vector<deUint32> bufs;
1011
1012         bufs.resize(drawBuffers.size());
1013
1014         for (int bufNdx = 0; bufNdx < (int)bufs.size(); bufNdx++)
1015                 bufs[bufNdx] = (drawBuffers[bufNdx].getRender() ? GL_COLOR_ATTACHMENT0 + bufNdx : GL_NONE);
1016
1017         log << program;
1018
1019         gl.viewport(0, 0, size.x(), size.y());
1020         gl.useProgram(program.getProgram());
1021         gl.bindFramebuffer(GL_FRAMEBUFFER, *framebuffer);
1022
1023         setCommonBlendState(gl, preCommonBlendState);
1024
1025         for (int renderbufferNdx = 0; renderbufferNdx < (int)drawBuffers.size(); renderbufferNdx++)
1026                 setIndexedBlendState(gl, drawBuffers[renderbufferNdx].getBlendState(), renderbufferNdx);
1027
1028         setCommonBlendState(gl, postCommonBlendState);
1029
1030         gl.drawBuffers((glw::GLsizei)bufs.size(), &(bufs[0]));
1031
1032         if (requiresBlendBarriers)
1033                 gl.blendBarrier();
1034
1035         renderGLQuad(renderContext, program);
1036
1037         if (requiresBlendBarriers)
1038                 gl.blendBarrier();
1039
1040         gl.drawBuffers(0, 0);
1041         gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
1042         gl.useProgram(0);
1043
1044         GLU_EXPECT_NO_ERROR(gl.getError(), "Failed to render");
1045
1046         renderRefQuad(preCommonBlendState, postCommonBlendState, drawBuffers, refRenderbuffers);
1047 }
1048
1049 void logBlendState (TestLog&                    log,
1050                                         const BlendState&       blend)
1051 {
1052         if (blend.enableBlend)
1053         {
1054                 if (*blend.enableBlend)
1055                         log << TestLog::Message << "Enable blending." << TestLog::EndMessage;
1056                 else
1057                         log << TestLog::Message << "Disable blending." << TestLog::EndMessage;
1058         }
1059
1060         if (blend.colorMask)
1061         {
1062                 const BVec4 mask = *blend.colorMask;
1063
1064                 log << TestLog::Message << "Set color mask: " << mask << "." << TestLog::EndMessage;
1065         }
1066
1067         if (blend.blendEq)
1068         {
1069                 const Either<BlendEq, SeparateBlendEq>& blendEq = *blend.blendEq;
1070
1071                 if (blendEq.is<BlendEq>())
1072                         log << TestLog::Message << "Set blend equation: " << glu::getBlendEquationStr(blendEq.get<BlendEq>()) << "." << TestLog::EndMessage;
1073                 else if (blendEq.is<SeparateBlendEq>())
1074                         log << TestLog::Message << "Set blend equation rgb: " << glu::getBlendEquationStr(blendEq.get<SeparateBlendEq>().rgb) << ", alpha: " << glu::getBlendEquationStr(blendEq.get<SeparateBlendEq>().alpha) << "." << TestLog::EndMessage;
1075                 else
1076                         DE_ASSERT(false);
1077         }
1078
1079         if (blend.blendFunc)
1080         {
1081                 const Either<BlendFunc, SeparateBlendFunc>& blendFunc = *blend.blendFunc;
1082
1083                 if (blendFunc.is<BlendFunc>())
1084                         log << TestLog::Message << "Set blend function source: " << glu::getBlendFactorStr(blendFunc.get<BlendFunc>().src) << ", destination: " << glu::getBlendFactorStr(blendFunc.get<BlendFunc>().dst) << "." << TestLog::EndMessage;
1085                 else if (blendFunc.is<SeparateBlendFunc>())
1086                 {
1087                         log << TestLog::Message << "Set blend function rgb source: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().rgb.src) << ", destination: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().rgb.dst) << "." << TestLog::EndMessage;
1088                         log << TestLog::Message << "Set blend function alpha source: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().alpha.src) << ", destination: " << glu::getBlendFactorStr(blendFunc.get<SeparateBlendFunc>().alpha.dst) << "." << TestLog::EndMessage;
1089                 }
1090                 else
1091                         DE_ASSERT(false);
1092         }
1093 }
1094
1095 void logTestCaseInfo (TestLog&                                          log,
1096                                           const BlendState&                             preCommonBlendState,
1097                                           const BlendState&                             postCommonBlendState,
1098                                           const vector<DrawBufferInfo>& drawBuffers)
1099 {
1100         {
1101                 tcu::ScopedLogSection drawBuffersSection(log, "DrawBuffers", "Draw buffers");
1102
1103                 for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
1104                 {
1105                         const tcu::ScopedLogSection     drawBufferSection       (log, "DrawBuffer" + de::toString(drawBufferNdx), "Draw Buffer " + de::toString(drawBufferNdx));
1106                         const DrawBufferInfo&           drawBuffer                      = drawBuffers[drawBufferNdx];
1107
1108                         log << TestLog::Message << "Format: " << drawBuffer.getFormat() << TestLog::EndMessage;
1109                         log << TestLog::Message << "Size: " << drawBuffer.getSize() << TestLog::EndMessage;
1110                         log << TestLog::Message << "Render: " << (drawBuffer.getRender() ? "true" : "false") << TestLog::EndMessage;
1111                 }
1112         }
1113
1114         if (!preCommonBlendState.isEmpty())
1115         {
1116                 tcu::ScopedLogSection s(log, "PreCommonState", "First set common blend state");
1117                 logBlendState(log, preCommonBlendState);
1118         }
1119
1120         for (int drawBufferNdx = 0; drawBufferNdx < (int)drawBuffers.size(); drawBufferNdx++)
1121         {
1122                 if (!drawBuffers[drawBufferNdx].getBlendState().isEmpty())
1123                 {
1124                         const tcu::ScopedLogSection s(log, "DrawBufferState" + de::toString(drawBufferNdx), "Set DrawBuffer " + de::toString(drawBufferNdx) + " state to");
1125
1126                         logBlendState(log, drawBuffers[drawBufferNdx].getBlendState());
1127                 }
1128         }
1129
1130         if (!postCommonBlendState.isEmpty())
1131         {
1132                 tcu::ScopedLogSection s(log, "PostCommonState", "After set common blend state");
1133                 logBlendState(log, postCommonBlendState);
1134         }
1135 }
1136
1137 void runTest (TestLog&                                          log,
1138                           tcu::ResultCollector&                 results,
1139                           glu::RenderContext&                   renderContext,
1140
1141                           const BlendState&                             preCommonBlendState,
1142                           const BlendState&                             postCommonBlendState,
1143                           const vector<DrawBufferInfo>& drawBuffers)
1144 {
1145         const glw::Functions&   gl                                      = renderContext.getFunctions();
1146         glu::RenderbufferVector renderbuffers           (gl, drawBuffers.size());
1147         glu::Framebuffer                framebuffer                     (gl);
1148         vector<TextureLevel>    refRenderbuffers        (drawBuffers.size());
1149
1150         logTestCaseInfo(log, preCommonBlendState, postCommonBlendState, drawBuffers);
1151
1152         genRenderbuffers(gl, drawBuffers, framebuffer, renderbuffers, refRenderbuffers);
1153
1154         renderQuad(log, renderContext, preCommonBlendState, postCommonBlendState, drawBuffers, framebuffer, refRenderbuffers);
1155
1156         verifyRenderbuffers(log, results, renderContext, renderbuffers, framebuffer, refRenderbuffers);
1157 }
1158
1159 class DrawBuffersIndexedTest : public TestCase
1160 {
1161 public:
1162                                         DrawBuffersIndexedTest (Context&                                                context,
1163                                                                                         const BlendState&                               preCommonBlendState,
1164                                                                                         const BlendState&                               postCommonBlendState,
1165                                                                                         const vector<DrawBufferInfo>&   drawBuffers,
1166                                                                                         const string&                                   name,
1167                                                                                         const string&                                   description);
1168
1169         void                    init                                    (void);
1170         IterateResult   iterate                                 (void);
1171
1172 private:
1173         const BlendState                                m_preCommonBlendState;
1174         const BlendState                                m_postCommonBlendState;
1175         const vector<DrawBufferInfo>    m_drawBuffers;
1176 };
1177
1178 DrawBuffersIndexedTest::DrawBuffersIndexedTest (Context&                                                context,
1179                                                                                                 const BlendState&                               preCommonBlendState,
1180                                                                                                 const BlendState&                               postCommonBlendState,
1181                                                                                                 const vector<DrawBufferInfo>&   drawBuffers,
1182                                                                                                 const string&                                   name,
1183                                                                                                 const string&                                   description)
1184         : TestCase                                      (context, name.c_str(), description.c_str())
1185         , m_preCommonBlendState         (preCommonBlendState)
1186         , m_postCommonBlendState        (postCommonBlendState)
1187         , m_drawBuffers                         (drawBuffers)
1188 {
1189 }
1190
1191 void DrawBuffersIndexedTest::init (void)
1192 {
1193         const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
1194
1195         if (!supportsES32)
1196         {
1197                 if (requiresAdvancedBlendEq(m_preCommonBlendState, m_postCommonBlendState, m_drawBuffers) && !m_context.getContextInfo().isExtensionSupported("GL_KHR_blend_equation_advanced"))
1198                         TCU_THROW(NotSupportedError, "Extension GL_KHR_blend_equation_advanced not supported");
1199
1200                 if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
1201                         TCU_THROW(NotSupportedError, "Extension GL_EXT_draw_buffers_indexed not supported");
1202         }
1203 }
1204
1205 TestCase::IterateResult DrawBuffersIndexedTest::iterate (void)
1206 {
1207         TestLog&                                log             = m_testCtx.getLog();
1208         tcu::ResultCollector    results (log);
1209
1210         runTest(log, results, m_context.getRenderContext(), m_preCommonBlendState, m_postCommonBlendState, m_drawBuffers);
1211
1212         results.setTestContextResult(m_testCtx);
1213
1214         return STOP;
1215 }
1216
1217 BlendEq getRandomBlendEq (de::Random& rng)
1218 {
1219         const BlendEq eqs[] =
1220         {
1221                 GL_FUNC_ADD,
1222                 GL_FUNC_SUBTRACT,
1223                 GL_FUNC_REVERSE_SUBTRACT,
1224                 GL_MIN,
1225                 GL_MAX
1226         };
1227
1228         return de::getSizedArrayElement<DE_LENGTH_OF_ARRAY(eqs)>(eqs, rng.getUint32() % DE_LENGTH_OF_ARRAY(eqs));
1229 }
1230
1231 BlendFunc getRandomBlendFunc (de::Random& rng)
1232 {
1233         const deUint32 funcs[] =
1234         {
1235                 GL_ZERO,
1236                 GL_ONE,
1237                 GL_SRC_COLOR,
1238                 GL_ONE_MINUS_SRC_COLOR,
1239                 GL_DST_COLOR,
1240                 GL_ONE_MINUS_DST_COLOR,
1241                 GL_SRC_ALPHA,
1242                 GL_ONE_MINUS_SRC_ALPHA,
1243                 GL_DST_ALPHA,
1244                 GL_ONE_MINUS_DST_ALPHA,
1245                 GL_CONSTANT_COLOR,
1246                 GL_ONE_MINUS_CONSTANT_COLOR,
1247                 GL_CONSTANT_ALPHA,
1248                 GL_ONE_MINUS_CONSTANT_ALPHA,
1249                 GL_SRC_ALPHA_SATURATE
1250         };
1251
1252         const deUint32 src = de::getSizedArrayElement<DE_LENGTH_OF_ARRAY(funcs)>(funcs, rng.getUint32() % DE_LENGTH_OF_ARRAY(funcs));
1253         const deUint32 dst = de::getSizedArrayElement<DE_LENGTH_OF_ARRAY(funcs)>(funcs, rng.getUint32() % DE_LENGTH_OF_ARRAY(funcs));
1254
1255         return BlendFunc(src, dst);
1256 }
1257
1258 void genRandomBlendState (de::Random& rng, BlendState& blendState)
1259 {
1260         if (rng.getBool())
1261                 blendState.enableBlend = rng.getBool();
1262
1263         if (rng.getBool())
1264         {
1265                 if (rng.getBool())
1266                         blendState.blendEq = getRandomBlendEq(rng);
1267                 else
1268                 {
1269                         const BlendEq   rgb             = getRandomBlendEq(rng);
1270                         const BlendEq   alpha   = getRandomBlendEq(rng);
1271
1272                         blendState.blendEq              = SeparateBlendEq(rgb, alpha);
1273                 }
1274         }
1275
1276         if (rng.getBool())
1277         {
1278                 if (rng.getBool())
1279                         blendState.blendFunc = getRandomBlendFunc(rng);
1280                 else
1281                 {
1282                         const BlendFunc rgb             = getRandomBlendFunc(rng);
1283                         const BlendFunc alpha   = getRandomBlendFunc(rng);
1284
1285                         blendState.blendFunc    = SeparateBlendFunc(rgb, alpha);
1286                 }
1287         }
1288
1289         if (rng.getBool())
1290         {
1291                 const bool red          = rng.getBool();
1292                 const bool green        = rng.getBool();
1293                 const bool blue         = rng.getBool();
1294                 const bool alpha        = rng.getBool();
1295
1296                 blendState.colorMask = BVec4(red, blue, green, alpha);
1297         }
1298 }
1299
1300 TextureFormat getRandomFormat (de::Random& rng, Context& context)
1301 {
1302         const bool supportsES32 = glu::contextSupports(context.getRenderContext().getType(), glu::ApiType::es(3, 2));
1303
1304         const deUint32 glFormats[] =
1305         {
1306                 GL_R8,
1307                 GL_RG8,
1308                 GL_RGB8,
1309                 GL_RGB565,
1310                 GL_RGBA4,
1311                 GL_RGB5_A1,
1312                 GL_RGBA8,
1313                 GL_RGB10_A2,
1314                 GL_RGB10_A2UI,
1315                 GL_R8I,
1316                 GL_R8UI,
1317                 GL_R16I,
1318                 GL_R16UI,
1319                 GL_R32I,
1320                 GL_R32UI,
1321                 GL_RG8I,
1322                 GL_RG8UI,
1323                 GL_RG16I,
1324                 GL_RG16UI,
1325                 GL_RG32I,
1326                 GL_RG32UI,
1327                 GL_RGBA8I,
1328                 GL_RGBA8UI,
1329                 GL_RGBA16I,
1330                 GL_RGBA16UI,
1331                 GL_RGBA32I,
1332                 GL_RGBA32UI,
1333                 GL_RGBA16F,
1334                 GL_R32F,
1335                 GL_RG32F,
1336                 GL_RGBA32F,
1337                 GL_R11F_G11F_B10F
1338         };
1339
1340         if (supportsES32)
1341                 return glu::mapGLInternalFormat(de::getArrayElement(glFormats, rng.getUint32() % DE_LENGTH_OF_ARRAY(glFormats)));
1342         else
1343         {
1344                 DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(glFormats) == 32);
1345                 return glu::mapGLInternalFormat(de::getArrayElement(glFormats, rng.getUint32() % (DE_LENGTH_OF_ARRAY(glFormats) - 5)));
1346         }
1347 }
1348
1349 void genRandomTest (de::Random& rng, BlendState& preCommon, BlendState& postCommon, vector<DrawBufferInfo>& drawBuffers, int maxDrawBufferCount, Context& context)
1350 {
1351         genRandomBlendState(rng, preCommon);
1352         genRandomBlendState(rng, postCommon);
1353
1354         for (int drawBufferNdx = 0; drawBufferNdx < maxDrawBufferCount; drawBufferNdx++)
1355         {
1356                 const bool                      render          = rng.getFloat() > 0.1f;
1357                 const IVec2                     size            (64, 64);
1358                 const TextureFormat     format          (getRandomFormat(rng, context));
1359                 BlendState                      blendState;
1360
1361                 genRandomBlendState(rng, blendState);
1362
1363                 // 32bit float formats don't support blending in GLES32
1364                 if (format.type == tcu::TextureFormat::FLOAT)
1365                 {
1366                         // If format is 32bit float post common can't enable blending
1367                         if (postCommon.enableBlend && *postCommon.enableBlend)
1368                         {
1369                                 // Either don't set enable blend or disable blending
1370                                 if (rng.getBool())
1371                                         postCommon.enableBlend = tcu::nothing<bool>();
1372                                 else
1373                                         postCommon.enableBlend = tcu::just(false);
1374                         }
1375
1376                         // If post common doesn't disable blending, per attachment state or
1377                         // pre common must.
1378                         if (!postCommon.enableBlend)
1379                         {
1380                                 // If pre common enables blend per attachment must disable it
1381                                 // If per attachment state changes blend state it must disable it
1382                                 if ((preCommon.enableBlend && *preCommon.enableBlend)
1383                                         || blendState.enableBlend)
1384                                         blendState.enableBlend = tcu::just(false);
1385                         }
1386                 }
1387
1388                 drawBuffers.push_back(DrawBufferInfo(render, size, blendState, format));
1389         }
1390 }
1391
1392 class MaxDrawBuffersIndexedTest : public TestCase
1393 {
1394 public:
1395                                         MaxDrawBuffersIndexedTest       (Context& contet, int seed);
1396
1397         void                    init                                            (void);
1398         IterateResult   iterate                                         (void);
1399
1400 private:
1401         const int               m_seed;
1402 };
1403
1404 MaxDrawBuffersIndexedTest::MaxDrawBuffersIndexedTest (Context& context, int seed)
1405         : TestCase      (context, de::toString(seed).c_str(), de::toString(seed).c_str())
1406         , m_seed        (deInt32Hash(seed) ^ 1558001307u)
1407 {
1408 }
1409
1410 void MaxDrawBuffersIndexedTest::init (void)
1411 {
1412         const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
1413
1414         if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
1415                 TCU_THROW(NotSupportedError, "Extension GL_EXT_draw_buffers_indexed not supported");
1416 }
1417
1418 TestCase::IterateResult MaxDrawBuffersIndexedTest::iterate (void)
1419 {
1420         TestLog&                                log                                             = m_testCtx.getLog();
1421         tcu::ResultCollector    results                                 (log);
1422         de::Random                              rng                                             (m_seed);
1423         BlendState                              preCommonBlendState;
1424         BlendState                              postCommonBlendState;
1425         vector<DrawBufferInfo>  drawBuffers;
1426
1427         genRandomTest(rng, preCommonBlendState, postCommonBlendState, drawBuffers, 4, m_context);
1428
1429         runTest(log, results, m_context.getRenderContext(), preCommonBlendState, postCommonBlendState, drawBuffers);
1430
1431         results.setTestContextResult(m_testCtx);
1432
1433         return STOP;
1434 }
1435
1436 class ImplMaxDrawBuffersIndexedTest : public TestCase
1437 {
1438 public:
1439                                         ImplMaxDrawBuffersIndexedTest   (Context& contet, int seed);
1440
1441         void                    init                                                    (void);
1442         IterateResult   iterate                                                 (void);
1443
1444 private:
1445         const int               m_seed;
1446 };
1447
1448 ImplMaxDrawBuffersIndexedTest::ImplMaxDrawBuffersIndexedTest (Context& context, int seed)
1449         : TestCase      (context, de::toString(seed).c_str(), de::toString(seed).c_str())
1450         , m_seed        (deInt32Hash(seed) ^ 2686315738u)
1451 {
1452 }
1453
1454 void ImplMaxDrawBuffersIndexedTest::init (void)
1455 {
1456         const bool supportsES32 = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2));
1457
1458         if (!supportsES32 && !m_context.getContextInfo().isExtensionSupported("GL_EXT_draw_buffers_indexed"))
1459                 TCU_THROW(NotSupportedError, "Extension GL_EXT_draw_buffers_indexed not supported");
1460 }
1461
1462 TestCase::IterateResult ImplMaxDrawBuffersIndexedTest::iterate (void)
1463 {
1464         TestLog&                                log                                             = m_testCtx.getLog();
1465         tcu::ResultCollector    results                                 (log);
1466         const glw::Functions&   gl                                              = m_context.getRenderContext().getFunctions();
1467         de::Random                              rng                                             (m_seed);
1468         deInt32                                 maxDrawBuffers                  = 0;
1469         BlendState                              preCommonBlendState;
1470         BlendState                              postCommonBlendState;
1471         vector<DrawBufferInfo>  drawBuffers;
1472
1473         gl.getIntegerv(GL_MAX_DRAW_BUFFERS, &maxDrawBuffers);
1474         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv(GL_MAX_DRAW_BUFFERS) failed");
1475
1476         TCU_CHECK(maxDrawBuffers > 0);
1477
1478         genRandomTest(rng, preCommonBlendState, postCommonBlendState, drawBuffers, maxDrawBuffers, m_context);
1479
1480         runTest(log, results, m_context.getRenderContext(), preCommonBlendState, postCommonBlendState, drawBuffers);
1481
1482         results.setTestContextResult(m_testCtx);
1483
1484         return STOP;
1485 }
1486
1487 enum PrePost
1488 {
1489         PRE,
1490         POST
1491 };
1492
1493 TestCase* createDiffTest (Context& context, PrePost prepost, const char* name, const BlendState& commonState, const BlendState& drawBufferState)
1494 {
1495         const BlendState emptyState = BlendState(tcu::nothing<bool>(), tcu::nothing<Either<BlendEq, SeparateBlendEq> >(), tcu::nothing<Either<BlendFunc, SeparateBlendFunc> >(), tcu::nothing<BVec4>());
1496
1497         if (prepost == PRE)
1498         {
1499                 const BlendState                preState        = BlendState((commonState.enableBlend ? commonState.enableBlend : just(true)),
1500                                                                                                                  commonState.blendEq,
1501                                                                                                                  (commonState.blendFunc ? commonState.blendFunc : just(Either<BlendFunc, SeparateBlendFunc>(BlendFunc(GL_ONE, GL_ONE)))),
1502                                                                                                                  tcu::nothing<BVec4>());
1503                 vector<DrawBufferInfo>  drawBuffers;
1504
1505                 drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), emptyState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
1506                 drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
1507
1508                 return new DrawBuffersIndexedTest(context, preState, emptyState, drawBuffers, name, name);
1509         }
1510         else if (prepost == POST)
1511         {
1512                 const BlendState                preState        = BlendState(just(true),
1513                                                                                                                  tcu::nothing<Either<BlendEq, SeparateBlendEq> >(),
1514                                                                                                                  Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_ONE, GL_ONE)),
1515                                                                                                                  tcu::nothing<BVec4>());
1516                 vector<DrawBufferInfo>  drawBuffers;
1517
1518                 drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), emptyState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
1519                 drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
1520
1521                 return new DrawBuffersIndexedTest(context, preState, commonState, drawBuffers, name, name);
1522         }
1523         else
1524         {
1525                 DE_ASSERT(false);
1526                 return DE_NULL;
1527         }
1528 }
1529
1530 TestCase* createAdvancedEqDiffTest (Context& context, PrePost prepost, const char* name, const BlendState& commonState, const BlendState& drawBufferState)
1531 {
1532         const BlendState emptyState = BlendState(tcu::nothing<bool>(), tcu::nothing<Either<BlendEq, SeparateBlendEq> >(), tcu::nothing<Either<BlendFunc, SeparateBlendFunc> >(), tcu::nothing<BVec4>());
1533
1534         if (prepost == PRE)
1535         {
1536                 const BlendState                preState        = BlendState((commonState.enableBlend ? commonState.enableBlend : just(true)),
1537                                                                                                                  commonState.blendEq,
1538                                                                                                                  (commonState.blendFunc ? commonState.blendFunc : just(Either<BlendFunc, SeparateBlendFunc>(BlendFunc(GL_ONE, GL_ONE)))),
1539                                                                                                                  tcu::nothing<BVec4>());
1540                 vector<DrawBufferInfo>  drawBuffers;
1541
1542                 drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
1543
1544                 return new DrawBuffersIndexedTest(context, preState, emptyState, drawBuffers, name, name);
1545         }
1546         else if (prepost == POST)
1547         {
1548                 const BlendState                preState        = BlendState(just(true),
1549                                                                                                                  tcu::nothing<Either<BlendEq, SeparateBlendEq> >(),
1550                                                                                                                  Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_ONE, GL_ONE)),
1551                                                                                                                  tcu::nothing<BVec4>());
1552                 vector<DrawBufferInfo>  drawBuffers;
1553
1554                 drawBuffers.push_back(DrawBufferInfo(true, IVec2(64, 64), drawBufferState, TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8)));
1555
1556                 return new DrawBuffersIndexedTest(context, preState, commonState, drawBuffers, name, name);
1557         }
1558         else
1559         {
1560                 DE_ASSERT(false);
1561                 return DE_NULL;
1562         }
1563 }
1564
1565 void addDrawBufferCommonTests (TestCaseGroup* root, PrePost prepost)
1566 {
1567         const BlendState                emptyState      = BlendState(Maybe<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1568
1569         {
1570                 const BlendState        disableState    = BlendState(just(false), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1571                 const BlendState        enableState             = BlendState(just(true), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1572
1573                 root->addChild(createDiffTest(root->getContext(), prepost, "common_enable_buffer_enable",       enableState,    enableState));
1574                 root->addChild(createDiffTest(root->getContext(), prepost, "common_disable_buffer_disable",     disableState,   disableState));
1575                 root->addChild(createDiffTest(root->getContext(), prepost, "common_disable_buffer_enable",      disableState,   enableState));
1576                 root->addChild(createDiffTest(root->getContext(), prepost, "common_enable_buffer_disable",      enableState,    disableState));
1577         }
1578
1579         {
1580                 const BlendState        eqStateA                        = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_FUNC_ADD), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1581                 const BlendState        eqStateB                        = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_FUNC_SUBTRACT), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1582
1583                 const BlendState        separateEqStateA        = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(SeparateBlendEq(GL_FUNC_ADD, GL_FUNC_SUBTRACT)), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1584                 const BlendState        separateEqStateB        = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(SeparateBlendEq(GL_FUNC_SUBTRACT, GL_FUNC_ADD)), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1585
1586                 const BlendState        advancedEqStateA        = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_DIFFERENCE), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1587                 const BlendState        advancedEqStateB        = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(GL_SCREEN), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1588
1589                 root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_eq_buffer_blend_eq", eqStateA, eqStateB));
1590                 root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_eq_buffer_separate_blend_eq", eqStateA, separateEqStateB));
1591                 root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_blend_eq_buffer_advanced_blend_eq", eqStateA, advancedEqStateB));
1592
1593                 root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_eq_buffer_blend_eq", separateEqStateA, eqStateB));
1594                 root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_eq_buffer_separate_blend_eq", separateEqStateA, separateEqStateB));
1595                 root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_separate_blend_eq_buffer_advanced_blend_eq", separateEqStateA, advancedEqStateB));
1596
1597                 root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_advanced_blend_eq_buffer_blend_eq", advancedEqStateA, eqStateB));
1598                 root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_advanced_blend_eq_buffer_separate_blend_eq", advancedEqStateA, separateEqStateB));
1599                 root->addChild(createAdvancedEqDiffTest(root->getContext(), prepost, "common_advanced_blend_eq_buffer_advanced_blend_eq", advancedEqStateA, advancedEqStateB));
1600         }
1601
1602         {
1603                 const BlendState        funcStateA                      = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA)), Maybe<BVec4>());
1604                 const BlendState        funcStateB                      = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(BlendFunc(GL_DST_ALPHA, GL_SRC_ALPHA)), Maybe<BVec4>());
1605                 const BlendState        separateFuncStateA      = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(SeparateBlendFunc(BlendFunc(GL_SRC_ALPHA, GL_DST_ALPHA), BlendFunc(GL_ONE_MINUS_SRC_ALPHA, GL_ONE_MINUS_DST_ALPHA))), Maybe<BVec4>());
1606                 const BlendState        separateFuncStateB      = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(SeparateBlendFunc(BlendFunc(GL_DST_ALPHA, GL_SRC_ALPHA), BlendFunc(GL_ONE_MINUS_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA))), Maybe<BVec4>());
1607
1608                 root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_func_buffer_blend_func",                                       funcStateA,                     funcStateB));
1609                 root->addChild(createDiffTest(root->getContext(), prepost, "common_blend_func_buffer_separate_blend_func",                      funcStateA,                     separateFuncStateB));
1610                 root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_func_buffer_blend_func",                      separateFuncStateA,     funcStateB));
1611                 root->addChild(createDiffTest(root->getContext(), prepost, "common_separate_blend_func_buffer_separate_blend_func",     separateFuncStateA,     separateFuncStateB));
1612         }
1613
1614         {
1615                 const BlendState        commonColorMaskState    = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>(BVec4(true, false, true, false)));
1616                 const BlendState        bufferColorMaskState    = BlendState(tcu::nothing<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>(BVec4(false, true, false, true)));
1617
1618                 root->addChild(createDiffTest(root->getContext(), prepost, "common_color_mask_buffer_color_mask", commonColorMaskState, bufferColorMaskState));
1619         }
1620 }
1621
1622 void addRandomMaxTest (TestCaseGroup* root)
1623 {
1624         for (int i = 0; i < 20; i++)
1625                 root->addChild(new MaxDrawBuffersIndexedTest(root->getContext(), i));
1626 }
1627
1628 void addRandomImplMaxTest (TestCaseGroup* root)
1629 {
1630         for (int i = 0; i < 20; i++)
1631                 root->addChild(new ImplMaxDrawBuffersIndexedTest(root->getContext(), i));
1632 }
1633
1634 } // anonymous
1635
1636 TestCaseGroup* createDrawBuffersIndexedTests (Context& context)
1637 {
1638         const BlendState                emptyState              = BlendState(Maybe<bool>(), Maybe<Either<BlendEq, SeparateBlendEq> >(), Maybe<Either<BlendFunc, SeparateBlendFunc> >(), Maybe<BVec4>());
1639         TestCaseGroup* const    group                   = new TestCaseGroup(context, "draw_buffers_indexed", "Test for indexed draw buffers. GL_EXT_draw_buffers_indexed.");
1640
1641         TestCaseGroup* const    preGroup                = new TestCaseGroup(context, "overwrite_common", "Set common state and overwrite it with draw buffer blend state.");
1642         TestCaseGroup* const    postGroup               = new TestCaseGroup(context, "overwrite_indexed", "Set indexed blend state and overwrite it with common state.");
1643         TestCaseGroup* const    randomGroup             = new TestCaseGroup(context, "random", "Random indexed blend state tests.");
1644         TestCaseGroup* const    maxGroup                = new TestCaseGroup(context, "max_required_draw_buffers", "Random tests using minimum maximum number of draw buffers.");
1645         TestCaseGroup* const    maxImplGroup    = new TestCaseGroup(context, "max_implementation_draw_buffers", "Random tests using maximum number of draw buffers reported by implementation.");
1646
1647         group->addChild(preGroup);
1648         group->addChild(postGroup);
1649         group->addChild(randomGroup);
1650
1651         randomGroup->addChild(maxGroup);
1652         randomGroup->addChild(maxImplGroup);
1653
1654         addDrawBufferCommonTests(preGroup, PRE);
1655         addDrawBufferCommonTests(postGroup, POST);
1656         addRandomMaxTest(maxGroup);
1657         addRandomImplMaxTest(maxImplGroup);
1658
1659         return group;
1660 }
1661
1662 } // Functional
1663 } // gles31
1664 } // deqp