modules/gles3/functional/es3fBlendTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.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 Blend tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fBlendTests.hpp"
  25 #include "gluStrUtil.hpp"
  26 #include "glsFragmentOpUtil.hpp"
  27 #include "gluPixelTransfer.hpp"
  28 #include "tcuPixelFormat.hpp"
  29 #include "tcuTexture.hpp"
  30 #include "tcuTextureUtil.hpp"
  31 #include "tcuImageCompare.hpp"
  32 #include "tcuRenderTarget.hpp"
  33 #include "tcuTestLog.hpp"
  34 #include "deRandom.hpp"
  35 #include "rrFragmentOperations.hpp"
  36 #include "sglrReferenceUtils.hpp"
  37
  38 #include <string>
  39 #include <vector>
  40
  41 #include "glw.h"
  42
  43 namespace deqp
  44 {
  45
  46 using gls::FragmentOpUtil::Quad;
  47 using gls::FragmentOpUtil::IntegerQuad;
  48 using gls::FragmentOpUtil::QuadRenderer;
  49 using gls::FragmentOpUtil::ReferenceQuadRenderer;
  50 using glu::getBlendEquationName;
  51 using glu::getBlendFactorName;
  52 using tcu::Vec4;
  53 using tcu::UVec4;
  54 using tcu::TestLog;
  55 using tcu::TextureLevel;
  56 using tcu::TextureFormat;
  57 using std::string;
  58 using std::vector;
  59
  60 namespace gles3
  61 {
  62 namespace Functional
  63 {
  64
  65 static const int MAX_VIEWPORT_WIDTH             = 64;
  66 static const int MAX_VIEWPORT_HEIGHT    = 64;
  67
  68 // \note src and dst can point to same memory as long as there is 1-to-1 correspondence between
  69 //               pixels.
  70 static void sRGBAToLinear (const tcu::PixelBufferAccess& dst, const tcu::ConstPixelBufferAccess& src)
  71 {
  72         const int       width   = src.getWidth();
  73         const int       height  = src.getHeight();
  74
  75         for (int y = 0; y < height; y++)
  76         for (int x = 0; x < width; x++)
  77                 dst.setPixel(tcu::sRGBToLinear(src.getPixel(x, y)), x, y);
  78 }
  79
  80 struct BlendParams
  81 {
  82         GLenum  equationRGB;
  83         GLenum  srcFuncRGB;
  84         GLenum  dstFuncRGB;
  85         GLenum  equationAlpha;
  86         GLenum  srcFuncAlpha;
  87         GLenum  dstFuncAlpha;
  88         Vec4    blendColor;
  89
  90         BlendParams (GLenum             equationRGB_,
  91                                  GLenum         srcFuncRGB_,
  92                                  GLenum         dstFuncRGB_,
  93                                  GLenum         equationAlpha_,
  94                                  GLenum         srcFuncAlpha_,
  95                                  GLenum         dstFuncAlpha_,
  96                                  Vec4           blendColor_)
  97         : equationRGB   (equationRGB_)
  98         , srcFuncRGB    (srcFuncRGB_)
  99         , dstFuncRGB    (dstFuncRGB_)
 100         , equationAlpha (equationAlpha_)
 101         , srcFuncAlpha  (srcFuncAlpha_)
 102         , dstFuncAlpha  (dstFuncAlpha_)
 103         , blendColor    (blendColor_)
 104         {
 105         }
 106 };
 107
 108 class BlendCase : public TestCase
 109 {
 110 public:
 111                                                         BlendCase       (Context&                                               context,
 112                                                                                  const char*                                    name,
 113                                                                                  const char*                                    desc,
 114                                                                                  const vector<BlendParams>&             paramSets,
 115                                                                                  bool                                                   useSrgbFbo);
 116
 117                                                         ~BlendCase      (void);
 118
 119         void                                    init            (void);
 120         void                                    deinit          (void);
 121
 122         IterateResult                   iterate         (void);
 123
 124 private:
 125                                                         BlendCase       (const BlendCase& other);
 126         BlendCase&                              operator=       (const BlendCase& other);
 127
 128         vector<BlendParams>             m_paramSets;
 129         int                                             m_curParamSetNdx;
 130
 131         bool                                    m_useSrgbFbo;
 132         deUint32                                m_colorRbo;
 133         deUint32                                m_fbo;
 134
 135         QuadRenderer*                   m_renderer;
 136         ReferenceQuadRenderer*  m_referenceRenderer;
 137         TextureLevel*                   m_refColorBuffer;
 138         Quad                                    m_firstQuad;
 139         Quad                                    m_secondQuad;
 140         IntegerQuad                             m_firstQuadInt;
 141         IntegerQuad                             m_secondQuadInt;
 142
 143         int                                             m_renderWidth;
 144         int                                             m_renderHeight;
 145         int                                             m_viewportWidth;
 146         int                                             m_viewportHeight;
 147 };
 148
 149 BlendCase::BlendCase (Context&                                          context,
 150                                           const char*                                   name,
 151                                           const char*                                   desc,
 152                                           const vector<BlendParams>&    paramSets,
 153                                           bool                                                  useSrgbFbo)
 154         : TestCase                              (context, name, desc)
 155         , m_paramSets                   (paramSets)
 156         , m_curParamSetNdx              (0)
 157         , m_useSrgbFbo                  (useSrgbFbo)
 158         , m_colorRbo                    (0)
 159         , m_fbo                                 (0)
 160         , m_renderer                    (DE_NULL)
 161         , m_referenceRenderer   (DE_NULL)
 162         , m_refColorBuffer              (DE_NULL)
 163         , m_renderWidth                 (m_useSrgbFbo ? 2*MAX_VIEWPORT_WIDTH    : m_context.getRenderTarget().getWidth())
 164         , m_renderHeight                (m_useSrgbFbo ? 2*MAX_VIEWPORT_HEIGHT   : m_context.getRenderTarget().getHeight())
 165         , m_viewportWidth               (0)
 166         , m_viewportHeight              (0)
 167 {
 168         DE_ASSERT(!m_paramSets.empty());
 169 }
 170
 171 void BlendCase::init (void)
 172 {
 173         bool useRGB = !m_useSrgbFbo && m_context.getRenderTarget().getPixelFormat().alphaBits == 0;
 174
 175         static const Vec4 baseGradientColors[4] =
 176         {
 177                 Vec4(0.0f, 0.5f, 1.0f, 0.5f),
 178                 Vec4(0.5f, 0.0f, 0.5f, 1.0f),
 179                 Vec4(0.5f, 1.0f, 0.5f, 0.0f),
 180                 Vec4(1.0f, 0.5f, 0.0f, 0.5f)
 181         };
 182
 183         DE_STATIC_ASSERT(DE_LENGTH_OF_ARRAY(m_firstQuad.color) == DE_LENGTH_OF_ARRAY(m_firstQuadInt.color));
 184         for (int i = 0; i < DE_LENGTH_OF_ARRAY(m_firstQuad.color); i++)
 185         {
 186                 m_firstQuad.color[i]            = (baseGradientColors[i] - 0.5f) * 0.2f + 0.5f;
 187                 m_firstQuadInt.color[i]         = m_firstQuad.color[i];
 188
 189                 m_secondQuad.color[i]           = (Vec4(1.0f) - baseGradientColors[i] - 0.5f) * 1.0f + 0.5f;
 190                 m_secondQuadInt.color[i]        = m_secondQuad.color[i];
 191         }
 192
 193         m_viewportWidth         = de::min<int>(m_renderWidth,   MAX_VIEWPORT_WIDTH);
 194         m_viewportHeight        = de::min<int>(m_renderHeight,  MAX_VIEWPORT_HEIGHT);
 195
 196         m_firstQuadInt.posA             = tcu::IVec2(0,                                         0);
 197         m_secondQuadInt.posA    = tcu::IVec2(0,                                         0);
 198         m_firstQuadInt.posB             = tcu::IVec2(m_viewportWidth-1,         m_viewportHeight-1);
 199         m_secondQuadInt.posB    = tcu::IVec2(m_viewportWidth-1,         m_viewportHeight-1);
 200
 201         DE_ASSERT(!m_renderer);
 202         DE_ASSERT(!m_referenceRenderer);
 203         DE_ASSERT(!m_refColorBuffer);
 204
 205         m_renderer                              = new QuadRenderer(m_context.getRenderContext(), glu::GLSL_VERSION_300_ES);
 206         m_referenceRenderer             = new ReferenceQuadRenderer;
 207         m_refColorBuffer                = new TextureLevel(TextureFormat(m_useSrgbFbo ? TextureFormat::sRGBA : useRGB ? TextureFormat::RGB : TextureFormat::RGBA, TextureFormat::UNORM_INT8),
 208                                                                                            m_viewportWidth, m_viewportHeight);
 209
 210         m_curParamSetNdx = 0;
 211
 212         if (m_useSrgbFbo)
 213         {
 214                 m_testCtx.getLog() << TestLog::Message << "Using FBO of size (" << m_renderWidth << ", " << m_renderHeight << ") with format GL_SRGB8_ALPHA8" << TestLog::EndMessage;
 215
 216                 GLU_CHECK_CALL(glGenRenderbuffers(1, &m_colorRbo));
 217                 GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, m_colorRbo));
 218                 GLU_CHECK_CALL(glRenderbufferStorage(GL_RENDERBUFFER, GL_SRGB8_ALPHA8, m_renderWidth, m_renderHeight));
 219
 220                 GLU_CHECK_CALL(glGenFramebuffers(1, &m_fbo));
 221                 GLU_CHECK_CALL(glBindFramebuffer(GL_FRAMEBUFFER, m_fbo));
 222                 GLU_CHECK_CALL(glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, m_colorRbo));
 223         }
 224 }
 225
 226 BlendCase::~BlendCase (void)
 227 {
 228         BlendCase::deinit();
 229 }
 230
 231 void BlendCase::deinit (void)
 232 {
 233         delete m_renderer;
 234         delete m_referenceRenderer;
 235         delete m_refColorBuffer;
 236
 237         m_renderer                      = DE_NULL;
 238         m_referenceRenderer     = DE_NULL;
 239         m_refColorBuffer        = DE_NULL;
 240
 241         GLU_CHECK_CALL(glBindRenderbuffer(GL_RENDERBUFFER, 0));
 242         GLU_CHECK_CALL(glBindFramebuffer(GL_FRAMEBUFFER, 0));
 243
 244         if (m_colorRbo != 0)
 245         {
 246                 GLU_CHECK_CALL(glDeleteRenderbuffers(1, &m_colorRbo));
 247                 m_colorRbo = 0;
 248         }
 249         if (m_fbo != 0)
 250         {
 251                 GLU_CHECK_CALL(glDeleteFramebuffers(1, &m_fbo));
 252                 m_fbo = 0;
 253         }
 254 }
 255
 256 BlendCase::IterateResult BlendCase::iterate (void)
 257 {
 258         de::Random                                              rnd                             (deStringHash(getName()) ^ deInt32Hash(m_curParamSetNdx));
 259         int                                                             viewportX               = rnd.getInt(0, m_renderWidth - m_viewportWidth);
 260         int                                                             viewportY               = rnd.getInt(0, m_renderHeight - m_viewportHeight);
 261         TextureLevel                                    renderedImg             (TextureFormat(m_useSrgbFbo ? TextureFormat::sRGBA : TextureFormat::RGBA, TextureFormat::UNORM_INT8), m_viewportWidth, m_viewportHeight);
 262         TextureLevel                                    referenceImg    (renderedImg.getFormat(), m_viewportWidth, m_viewportHeight);
 263         TestLog&                                                log                             (m_testCtx.getLog());
 264         const BlendParams&                              paramSet                = m_paramSets[m_curParamSetNdx];
 265         rr::FragmentOperationState              referenceState;
 266
 267         // Log the blend parameters.
 268
 269         log << TestLog::Message << "RGB equation = " << getBlendEquationName(paramSet.equationRGB) << TestLog::EndMessage;
 270         log << TestLog::Message << "RGB src func = " << getBlendFactorName(paramSet.srcFuncRGB) << TestLog::EndMessage;
 271         log << TestLog::Message << "RGB dst func = " << getBlendFactorName(paramSet.dstFuncRGB) << TestLog::EndMessage;
 272         log << TestLog::Message << "Alpha equation = " << getBlendEquationName(paramSet.equationAlpha) << TestLog::EndMessage;
 273         log << TestLog::Message << "Alpha src func = " << getBlendFactorName(paramSet.srcFuncAlpha) << TestLog::EndMessage;
 274         log << TestLog::Message << "Alpha dst func = " << getBlendFactorName(paramSet.dstFuncAlpha) << TestLog::EndMessage;
 275         log << TestLog::Message << "Blend color = (" << paramSet.blendColor.x() << ", " << paramSet.blendColor.y() << ", " << paramSet.blendColor.z() << ", " << paramSet.blendColor.w() << ")" << TestLog::EndMessage;
 276
 277         // Set GL state.
 278
 279         GLU_CHECK_CALL(glBlendEquationSeparate(paramSet.equationRGB, paramSet.equationAlpha));
 280         GLU_CHECK_CALL(glBlendFuncSeparate(paramSet.srcFuncRGB, paramSet.dstFuncRGB, paramSet.srcFuncAlpha, paramSet.dstFuncAlpha));
 281         GLU_CHECK_CALL(glBlendColor(paramSet.blendColor.x(), paramSet.blendColor.y(), paramSet.blendColor.z(), paramSet.blendColor.w()));
 282
 283         // Set reference state.
 284
 285         referenceState.blendRGBState.equation   = sglr::rr_util::mapGLBlendEquation(paramSet.equationRGB);
 286         referenceState.blendRGBState.srcFunc    = sglr::rr_util::mapGLBlendFunc(paramSet.srcFuncRGB);
 287         referenceState.blendRGBState.dstFunc    = sglr::rr_util::mapGLBlendFunc(paramSet.dstFuncRGB);
 288         referenceState.blendAState.equation             = sglr::rr_util::mapGLBlendEquation(paramSet.equationAlpha);
 289         referenceState.blendAState.srcFunc              = sglr::rr_util::mapGLBlendFunc(paramSet.srcFuncAlpha);
 290         referenceState.blendAState.dstFunc              = sglr::rr_util::mapGLBlendFunc(paramSet.dstFuncAlpha);
 291         referenceState.blendColor                               = paramSet.blendColor;
 292
 293         // Render with GL.
 294
 295         glDisable(GL_BLEND);
 296         glViewport(viewportX, viewportY, m_viewportWidth, m_viewportHeight);
 297         m_renderer->render(m_firstQuad);
 298         glEnable(GL_BLEND);
 299         m_renderer->render(m_secondQuad);
 300         glFlush();
 301
 302         // Render reference.
 303
 304         const tcu::PixelBufferAccess nullAccess = tcu::PixelBufferAccess();
 305
 306         referenceState.blendMode = rr::BLENDMODE_NONE;
 307         m_referenceRenderer->render(gls::FragmentOpUtil::getMultisampleAccess(m_refColorBuffer->getAccess()), nullAccess /* no depth */, nullAccess /* no stencil */, m_firstQuadInt, referenceState);
 308         referenceState.blendMode = rr::BLENDMODE_STANDARD;
 309         m_referenceRenderer->render(gls::FragmentOpUtil::getMultisampleAccess(m_refColorBuffer->getAccess()), nullAccess /* no depth */, nullAccess /* no stencil */, m_secondQuadInt, referenceState);
 310
 311         // Copy to reference (expansion to RGBA happens here if necessary)
 312         copy(referenceImg, m_refColorBuffer->getAccess());
 313
 314         // Read GL image.
 315
 316         glu::readPixels(m_context.getRenderContext(), viewportX, viewportY, renderedImg.getAccess());
 317
 318         // Compare images.
 319         // \note In sRGB cases, convert to linear space for comparison.
 320
 321         if (m_useSrgbFbo)
 322         {
 323                 sRGBAToLinear(renderedImg, renderedImg);
 324                 sRGBAToLinear(referenceImg, referenceImg);
 325         }
 326
 327         UVec4 compareThreshold = (m_useSrgbFbo ? tcu::PixelFormat(8, 8, 8, 8) : m_context.getRenderTarget().getPixelFormat()).getColorThreshold().toIVec().asUint()
 328                                                          * UVec4(5) / UVec4(2) + UVec4(m_useSrgbFbo ? 5 : 2); // \note Non-scientific ad hoc formula. Need big threshold when few color bits; blending brings extra inaccuracy.
 329
 330         bool comparePass = tcu::intThresholdCompare(m_testCtx.getLog(), "CompareResult", "Image Comparison Result",
 331                                                                                                 referenceImg.getAccess(), renderedImg.getAccess(),
 332                                                                                                 compareThreshold, tcu::COMPARE_LOG_RESULT);
 333
 334         // Fail now if images don't match.
 335
 336         if (!comparePass)
 337         {
 338                 m_context.getTestContext().setTestResult(QP_TEST_RESULT_FAIL, "Image compare failed");
 339                 return STOP;
 340         }
 341
 342         // Continue if param sets still remain in m_paramSets; otherwise stop.
 343
 344         m_curParamSetNdx++;
 345
 346         if (m_curParamSetNdx < (int)m_paramSets.size())
 347                 return CONTINUE;
 348         else
 349         {
 350                 m_context.getTestContext().setTestResult(QP_TEST_RESULT_PASS, "Passed");
 351                 return STOP;
 352         }
 353 }
 354
 355 BlendTests::BlendTests (Context& context)
 356         : TestCaseGroup(context, "blend", "Blend tests")
 357 {
 358 }
 359
 360 BlendTests::~BlendTests (void)
 361 {
 362 }
 363
 364 void BlendTests::init (void)
 365 {
 366         struct EnumGL
 367         {
 368                 GLenum                  glValue;
 369                 const char*             nameStr;
 370         };
 371
 372         static const EnumGL blendEquations[] =
 373         {
 374                 { GL_FUNC_ADD,                                  "add"                                   },
 375                 { GL_FUNC_SUBTRACT,                             "subtract"                              },
 376                 { GL_FUNC_REVERSE_SUBTRACT,             "reverse_subtract"              },
 377                 { GL_MIN,                                               "min"                                   },
 378                 { GL_MAX,                                               "max"                                   }
 379         };
 380
 381         static const EnumGL blendFunctions[] =
 382         {
 383                 { GL_ZERO,                                                      "zero"                                          },
 384                 { GL_ONE,                                                       "one"                                           },
 385                 { GL_SRC_COLOR,                                         "src_color"                                     },
 386                 { GL_ONE_MINUS_SRC_COLOR,                       "one_minus_src_color"           },
 387                 { GL_DST_COLOR,                                         "dst_color"                                     },
 388                 { GL_ONE_MINUS_DST_COLOR,                       "one_minus_dst_color"           },
 389                 { GL_SRC_ALPHA,                                         "src_alpha"                                     },
 390                 { GL_ONE_MINUS_SRC_ALPHA,                       "one_minus_src_alpha"           },
 391                 { GL_DST_ALPHA,                                         "dst_alpha"                                     },
 392                 { GL_ONE_MINUS_DST_ALPHA,                       "one_minus_dst_alpha"           },
 393                 { GL_CONSTANT_COLOR,                            "constant_color"                        },
 394                 { GL_ONE_MINUS_CONSTANT_COLOR,          "one_minus_constant_color"      },
 395                 { GL_CONSTANT_ALPHA,                            "constant_alpha"                        },
 396                 { GL_ONE_MINUS_CONSTANT_ALPHA,          "one_minus_constant_alpha"      },
 397                 { GL_SRC_ALPHA_SATURATE,                        "src_alpha_saturate"            }
 398         };
 399
 400         const Vec4 defaultBlendColor(0.2f, 0.4f, 0.6f, 0.8f);
 401
 402         for (int useSrgbFboI = 0; useSrgbFboI <= 1; useSrgbFboI++)
 403         {
 404                 bool                    useSrgbFbo      = useSrgbFboI != 0;
 405                 TestCaseGroup*  fbGroup         = new TestCaseGroup(m_context, useSrgbFbo ? "fbo_srgb" : "default_framebuffer", useSrgbFbo ? "Use a FBO with GL_SRGB8_ALPHA8" : "Use the default framebuffer");
 406                 addChild(fbGroup);
 407
 408                 // Test all blend equation, src blend function, dst blend function combinations. RGB and alpha modes are the same.
 409
 410                 {
 411                         TestCaseGroup* group = new TestCaseGroup(m_context, "equation_src_func_dst_func", "Combinations of Blend Equations and Functions");
 412                         fbGroup->addChild(group);
 413
 414                         for (int equationNdx = 0;       equationNdx < DE_LENGTH_OF_ARRAY(blendEquations);       equationNdx++)
 415                         for (int srcFuncNdx = 0;        srcFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);        srcFuncNdx++)
 416                         for (int dstFuncNdx = 0;        dstFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);        dstFuncNdx++)
 417                         {
 418                                 const EnumGL& eq        = blendEquations[equationNdx];
 419                                 const EnumGL& src       = blendFunctions[srcFuncNdx];
 420                                 const EnumGL& dst       = blendFunctions[dstFuncNdx];
 421
 422                                 if ((eq.glValue == GL_MIN || eq.glValue == GL_MAX) && (srcFuncNdx > 0 || dstFuncNdx > 0)) // MIN and MAX don't depend on factors.
 423                                         continue;
 424
 425                                 string name                     = eq.nameStr;
 426                                 string description      = string("") +
 427                                                                           "Equations "          + getBlendEquationName(eq.glValue) +
 428                                                                           ", src funcs "        + getBlendFactorName(src.glValue) +
 429                                                                           ", dst funcs "        + getBlendFactorName(dst.glValue);
 430
 431                                 if (eq.glValue != GL_MIN && eq.glValue != GL_MAX)
 432                                         name += string("") + "_" + src.nameStr + "_" + dst.nameStr;
 433
 434                                 vector<BlendParams> paramSets;
 435                                 paramSets.push_back(BlendParams(eq.glValue, src.glValue, dst.glValue, eq.glValue, src.glValue, dst.glValue, defaultBlendColor));
 436
 437                                 group->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets, useSrgbFbo));
 438                         }
 439                 }
 440
 441                 // Test all RGB src, alpha src and RGB dst, alpha dst combinations. Equations are ADD.
 442                 // \note For all RGB src, alpha src combinations, also test a couple of different RGBA dst functions, and vice versa.
 443
 444                 {
 445                         TestCaseGroup* mainGroup = new TestCaseGroup(m_context, "rgb_func_alpha_func", "Combinations of RGB and Alpha Functions");
 446                         fbGroup->addChild(mainGroup);
 447                         TestCaseGroup* srcGroup = new TestCaseGroup(m_context, "src", "Source functions");
 448                         TestCaseGroup* dstGroup = new TestCaseGroup(m_context, "dst", "Destination functions");
 449                         mainGroup->addChild(srcGroup);
 450                         mainGroup->addChild(dstGroup);
 451
 452                         for (int isDstI = 0;            isDstI <= 1;                                                                            isDstI++)
 453                         for (int rgbFuncNdx = 0;        rgbFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);        rgbFuncNdx++)
 454                         for (int alphaFuncNdx = 0;      alphaFuncNdx < DE_LENGTH_OF_ARRAY(blendFunctions);      alphaFuncNdx++)
 455                         {
 456                                 bool                    isSrc                   = isDstI == 0;
 457                                 TestCaseGroup*  curGroup                = isSrc ? srcGroup : dstGroup;
 458                                 const EnumGL&   funcRGB                 = blendFunctions[rgbFuncNdx];
 459                                 const EnumGL&   funcAlpha               = blendFunctions[alphaFuncNdx];
 460                                 const char*             dstOrSrcStr             = isSrc ? "src" : "dst";
 461
 462                                 string name                     = string("") + funcRGB.nameStr + "_" + funcAlpha.nameStr;
 463                                 string description      = string("") +
 464                                                                           "RGB "                + dstOrSrcStr + " func " + getBlendFactorName(funcRGB.glValue) +
 465                                                                           ", alpha "    + dstOrSrcStr + " func " + getBlendFactorName(funcAlpha.glValue);
 466
 467                                 // First, make param sets as if this was a src case.
 468
 469                                 vector<BlendParams> paramSets;
 470                                 paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_ONE,                   GL_FUNC_ADD, funcAlpha.glValue, GL_ONE,                 defaultBlendColor));
 471                                 paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_ZERO,                  GL_FUNC_ADD, funcAlpha.glValue, GL_ZERO,                defaultBlendColor));
 472                                 paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_SRC_COLOR,             GL_FUNC_ADD, funcAlpha.glValue, GL_SRC_COLOR,   defaultBlendColor));
 473                                 paramSets.push_back(BlendParams(GL_FUNC_ADD, funcRGB.glValue, GL_DST_COLOR,             GL_FUNC_ADD, funcAlpha.glValue, GL_DST_COLOR,   defaultBlendColor));
 474
 475                                 // Swap src and dst params if this is a dst case.
 476
 477                                 if (!isSrc)
 478                                 {
 479                                         for (int i = 0; i < (int)paramSets.size(); i++)
 480                                         {
 481                                                 std::swap(paramSets[i].srcFuncRGB,              paramSets[i].dstFuncRGB);
 482                                                 std::swap(paramSets[i].srcFuncAlpha,    paramSets[i].dstFuncAlpha);
 483                                         }
 484                                 }
 485
 486                                 curGroup->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets, useSrgbFbo));
 487                         }
 488                 }
 489
 490                 // Test all RGB and alpha equation combinations. Src and dst funcs are ONE for both.
 491
 492                 {
 493                         TestCaseGroup* group = new TestCaseGroup(m_context, "rgb_equation_alpha_equation", "Combinations of RGB and Alpha Equation Combinations");
 494                         fbGroup->addChild(group);
 495
 496                         for (int equationRGBNdx = 0;    equationRGBNdx < DE_LENGTH_OF_ARRAY(blendEquations);    equationRGBNdx++)
 497                         for (int equationAlphaNdx = 0;  equationAlphaNdx < DE_LENGTH_OF_ARRAY(blendEquations);  equationAlphaNdx++)
 498                         {
 499                                 const EnumGL& eqRGB                     = blendEquations[equationRGBNdx];
 500                                 const EnumGL& eqAlpha           = blendEquations[equationAlphaNdx];
 501
 502                                 string name                     = string("") + eqRGB.nameStr + "_" + eqAlpha.nameStr;
 503                                 string description      = string("") +
 504                                                                           "RGB equation "               + getBlendEquationName(eqRGB.glValue) +
 505                                                                           ", alpha equation "   + getBlendEquationName(eqAlpha.glValue);
 506
 507                                 vector<BlendParams> paramSets;
 508                                 paramSets.push_back(BlendParams(eqRGB.glValue, GL_ONE, GL_ONE, eqAlpha.glValue, GL_ONE, GL_ONE, defaultBlendColor));
 509
 510                                 group->addChild(new BlendCase(m_context, name.c_str(), description.c_str(), paramSets, useSrgbFbo));
 511                         }
 512                 }
 513         }
 514 }
 515
 516 } // Functional
 517 } // gles3
 518 } // deqp