modules/gles31/functional/es31fFboSRGBWriteControlTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2017 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 FBO sRGB tests.
  22 *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fFboSRGBWriteControlTests.hpp"
  25 #include "es31fFboTestUtil.hpp"
  26 #include "gluTextureUtil.hpp"
  27 #include "gluContextInfo.hpp"
  28 #include "tcuTestLog.hpp"
  29 #include "glwEnums.hpp"
  30 #include "sglrContextUtil.hpp"
  31 #include "glwFunctions.hpp"
  32 #include "deUniquePtr.hpp"
  33 #include "deSharedPtr.hpp"
  34 #include "gluObjectWrapper.hpp"
  35 #include "gluPixelTransfer.hpp"
  36 #include "glsTextureTestUtil.hpp"
  37 #include "tcuVectorUtil.hpp"
  38 #include "gluStrUtil.hpp"
  39
  40 namespace deqp
  41 {
  42 namespace gles31
  43 {
  44 namespace Functional
  45 {
  46 namespace
  47 {
  48
  49 tcu::Vec4 getTestColorLinear (void)
  50 {
  51         return tcu::Vec4(0.2f, 0.3f, 0.4f, 1.0f);
  52 }
  53
  54 tcu::Vec4 getTestColorSRGB (void)
  55 {
  56         return linearToSRGB(tcu::Vec4(0.2f, 0.3f, 0.4f, 1.0f));
  57 }
  58
  59 tcu::Vec4 getTestColorBlank (void)
  60 {
  61         return tcu::Vec4(0.0f, 0.0f, 0.0f, 1.0f);
  62 }
  63
  64 tcu::Vec4 getEpsilonError (void)
  65 {
  66         return tcu::Vec4(0.005f);
  67 }
  68
  69 enum QueryType
  70 {
  71         QUERYTYPE_ISENABLED = 0,
  72         QUERYTYPE_BOOLEAN,
  73         QUERYTYPE_FLOAT,
  74         QUERYTYPE_INT,
  75         QUERYTYPE_INT64,
  76         QUERYTYPE_LAST
  77 };
  78
  79 enum DataType
  80 {
  81         DATATYPE_BOOLEAN = 0,
  82         DATATYPE_FLOAT,
  83         DATATYPE_INT,
  84         DATATYPE_INT64,
  85 };
  86
  87 enum FramebufferSRGB
  88 {
  89         FRAMEBUFFERSRGB_ENABLED = 0,
  90         FRAMEBUFFERSRGB_DISABLED
  91 };
  92
  93 enum FramebufferBlend
  94 {
  95         FRAMEBUFFERBLEND_ENABLED = 0,
  96         FRAMEBUFFERBLEND_DISABLED
  97 };
  98
  99 enum TextureSourcesType
 100 {
 101         TEXTURESOURCESTYPE_RGBA         = 0,
 102         TEXTURESOURCESTYPE_SRGBA,
 103         TEXTURESOURCESTYPE_BOTH,
 104         TEXTURESOURCESTYPE_NONE
 105 };
 106
 107 enum FboType
 108 {
 109         FBOTYPE_SOURCE                  = 0,
 110         FBOTYPE_DESTINATION
 111 };
 112
 113 enum RendererTask
 114 {
 115         RENDERERTASK_DRAW = 0,
 116         RENDERERTASK_COPY
 117 };
 118
 119 enum SamplingType
 120 {
 121         SAMPLINGTYPE_TEXTURE                    = 0,
 122         SAMPLINGTYPE_TEXTURE_LOD,
 123         SAMPLINGTYPE_TEXTURE_GRAD,
 124         SAMPLINGTYPE_TEXTURE_OFFSET,
 125         SAMPLINGTYPE_TEXTURE_PROJ,
 126 };
 127
 128 namespace TestTextureSizes
 129 {
 130         const int WIDTH = 128;
 131         const int HEIGHT = 128;
 132 } // global test texture sizes
 133
 134 namespace SampligTypeCount
 135 {
 136         const int MAX = 5;
 137 } // global max number of sampling types
 138
 139 std::string buildSamplingPassType (const int samplerTotal)
 140 {
 141         std::ostringstream      shaderFragment;
 142
 143         const SamplingType      samplingTypeList [] =
 144         {
 145                 SAMPLINGTYPE_TEXTURE, SAMPLINGTYPE_TEXTURE_LOD, SAMPLINGTYPE_TEXTURE_GRAD, SAMPLINGTYPE_TEXTURE_OFFSET, SAMPLINGTYPE_TEXTURE_PROJ
 146         } ;
 147
 148         for (int samplerTypeIdx = 0; samplerTypeIdx < DE_LENGTH_OF_ARRAY(samplingTypeList); samplerTypeIdx++)
 149         {
 150                 shaderFragment
 151                         << "    if (uFunctionType == " << samplerTypeIdx << ") \n"
 152                         << "    { \n";
 153
 154                 for (int samplerIdx = 0; samplerIdx < samplerTotal; samplerIdx++)
 155                 {
 156                         switch (static_cast<SamplingType>(samplerTypeIdx))
 157                         {
 158                                 case SAMPLINGTYPE_TEXTURE:
 159                                 {
 160                                         shaderFragment
 161                                                 << "            texelColor" << samplerIdx << " = texture(uTexture" << samplerIdx << ", vs_aTexCoord); \n";
 162                                         break;
 163                                 }
 164                                 case SAMPLINGTYPE_TEXTURE_LOD:
 165                                 {
 166                                         shaderFragment
 167                                                 << "            texelColor" << samplerIdx << " = textureLod(uTexture" << samplerIdx << ", vs_aTexCoord, 0.0f); \n";
 168                                         break;
 169                                 }
 170                                 case SAMPLINGTYPE_TEXTURE_GRAD:
 171                                 {
 172                                         shaderFragment
 173                                                 << "            texelColor" << samplerIdx << " = textureGrad(uTexture" << samplerIdx << ", vs_aTexCoord, vec2(0.0f, 0.0f), vec2(0.0f, 0.0f)); \n";
 174                                         break;
 175                                 }
 176                                 case SAMPLINGTYPE_TEXTURE_OFFSET:
 177                                 {
 178                                         shaderFragment
 179                                                 << "            texelColor" << samplerIdx << " = textureOffset(uTexture" << samplerIdx << ", vs_aTexCoord, ivec2(0.0f, 0.0f)); \n";
 180                                         break;
 181                                 }
 182                                 case SAMPLINGTYPE_TEXTURE_PROJ:
 183                                 {
 184                                         shaderFragment
 185                                                 << "            texelColor" << samplerIdx << " = textureProj(uTexture" << samplerIdx << ", vec3(vs_aTexCoord, 1.0f)); \n";
 186                                         break;
 187                                 }
 188                                 default:
 189                                         DE_FATAL("Error: sampling type unrecognised");
 190                         }
 191                 }
 192
 193                 shaderFragment
 194                         << "    } \n";
 195         }
 196
 197         return shaderFragment.str();
 198 }
 199
 200 void logColor (Context& context, const std::string& colorLogMessage, const tcu::Vec4 resultColor)
 201 {
 202         tcu::TestLog&                   log             = context.getTestContext().getLog();
 203         std::ostringstream              message;
 204
 205         message << colorLogMessage << " = (" << resultColor.x() << ", " << resultColor.y() << ", " << resultColor.z() << ", " << resultColor.w() << ")";
 206                 log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
 207 }
 208
 209 struct TestFunction
 210 {
 211         explicit TestFunction   (const bool hasFunctionValue)
 212                 : hasFunction           (hasFunctionValue) {}
 213         TestFunction                    (const char* const functionNameValue, const char* const functionDefinition)
 214                 : hasFunction           (true)
 215                 , functionName          (functionNameValue)
 216                 , functionDefintion     (functionDefinition) {}
 217         ~TestFunction                   (void) {}
 218
 219         bool                    hasFunction;
 220         const char*             functionName;
 221         const char*             functionDefintion;
 222 };
 223
 224 TestFunction getFunctionBlendLinearToSRGBCheck (void)
 225 {
 226         const char* const functionName = "blendPlusLinearToSRGB";
 227
 228         const char* const functionDefinition =
 229                 "mediump vec4 blendPlusLinearToSRGB(in mediump vec4 colorSrc, in mediump vec4 colorDst) \n"
 230                 "{ \n"
 231                 "       const int MAX_VECTOR_SIZE = 4; \n"
 232                 "       mediump vec4 colorConverted; \n"
 233                 "       mediump vec4 colorBlended; \n"
 234                 "       for (int idx = 0; idx < MAX_VECTOR_SIZE; idx++) \n"
 235                 "       { \n"
 236                 "               if (uBlendFunctionType == 0) \n"
 237                 "               { \n"
 238                 "                       colorBlended[idx] = (colorSrc[idx] * uFactorSrc) + colorDst[idx] * uFactorDst; \n"
 239                 "               } \n"
 240                 "               if (uBlendFunctionType == 1) \n"
 241                 "               { \n"
 242                 "                       colorBlended[idx] = (colorSrc[idx] * uFactorSrc) - (colorDst[idx] * uFactorDst); \n"
 243                 "               } \n"
 244                                 "if (uBlendFunctionType == 2) \n"
 245                 "               { \n"
 246                 "                       colorBlended[idx] = (colorDst[idx] * uFactorDst) - (colorSrc[idx] * uFactorSrc); \n"
 247                 "               } \n"
 248                 "               if (colorBlended[idx] < 0.0031308f) \n"
 249                 "               { \n"
 250                 "                       colorConverted[idx] = 12.92f * colorBlended[idx]; \n"
 251                 "               } \n"
 252                 "               else \n"
 253                 "               { \n"
 254                 "                       colorConverted[idx] = 1.055f * pow(colorBlended[idx], 0.41666f) - 0.055f; \n"
 255                 "               } \n"
 256                 "       } \n"
 257                 "       return colorConverted; \n"
 258                 "} \n";
 259
 260         TestFunction testFunction(functionName, functionDefinition);
 261
 262         return testFunction;
 263 }
 264
 265 struct FBOConfig
 266 {
 267         FBOConfig                                       (const deUint32 textureInternalFormatValue,
 268                                                                  const tcu::Vec4 textureColorValue,
 269                                                                  const deUint32 fboTargetTypeValue,
 270                                                                  const deUint32 fboColorAttachmentValue,
 271                                                                  const FboType fboTypeValue)
 272                 : textureInternalFormat (textureInternalFormatValue)
 273                 , textureColor                  (textureColorValue)
 274                 , fboTargetType                 (fboTargetTypeValue)
 275                 , fboColorAttachment    (fboColorAttachmentValue)
 276                 , fboType                               (fboTypeValue) {}
 277         ~FBOConfig                                      (void) {}
 278
 279         deUint32        textureInternalFormat;
 280         tcu::Vec4       textureColor;
 281         deUint32        fboTargetType;
 282         deUint32        fboColorAttachment;
 283         FboType         fboType;
 284 };
 285
 286 struct BlendConfig
 287 {
 288         deUint32        equation;
 289         deUint32        funcSrc;
 290         deUint32        funcDst;
 291 };
 292
 293 std::vector<BlendConfig> getBlendingConfigList (void)
 294 {
 295         BlendConfig blendConfigs[12];
 296
 297         // add function permutations
 298         blendConfigs[0].equation = GL_FUNC_ADD;
 299         blendConfigs[1].equation = GL_FUNC_ADD;
 300         blendConfigs[2].equation = GL_FUNC_ADD;
 301         blendConfigs[3].equation = GL_FUNC_ADD;
 302
 303         blendConfigs[0].funcSrc = GL_ONE;
 304         blendConfigs[0].funcDst = GL_ONE;
 305         blendConfigs[1].funcSrc = GL_ONE;
 306         blendConfigs[1].funcDst = GL_ZERO;
 307         blendConfigs[2].funcSrc = GL_ZERO;
 308         blendConfigs[2].funcDst = GL_ONE;
 309         blendConfigs[3].funcSrc = GL_ZERO;
 310         blendConfigs[3].funcDst = GL_ZERO;
 311
 312         // subtract function permutations
 313         blendConfigs[4].equation = GL_FUNC_SUBTRACT;
 314         blendConfigs[5].equation = GL_FUNC_SUBTRACT;
 315         blendConfigs[6].equation = GL_FUNC_SUBTRACT;
 316         blendConfigs[7].equation = GL_FUNC_SUBTRACT;
 317
 318         blendConfigs[4].funcSrc = GL_ONE;
 319         blendConfigs[4].funcDst = GL_ONE;
 320         blendConfigs[5].funcSrc = GL_ONE;
 321         blendConfigs[5].funcDst = GL_ZERO;
 322         blendConfigs[6].funcSrc = GL_ZERO;
 323         blendConfigs[6].funcDst = GL_ONE;
 324         blendConfigs[7].funcSrc = GL_ZERO;
 325         blendConfigs[7].funcDst = GL_ZERO;
 326
 327         // reverse subtract function permutations
 328         blendConfigs[8].equation = GL_FUNC_REVERSE_SUBTRACT;
 329         blendConfigs[9].equation = GL_FUNC_REVERSE_SUBTRACT;
 330         blendConfigs[10].equation = GL_FUNC_REVERSE_SUBTRACT;
 331         blendConfigs[11].equation = GL_FUNC_REVERSE_SUBTRACT;
 332
 333         blendConfigs[8].funcSrc = GL_ONE;
 334         blendConfigs[8].funcDst = GL_ONE;
 335         blendConfigs[9].funcSrc = GL_ONE;
 336         blendConfigs[9].funcDst = GL_ZERO;
 337         blendConfigs[10].funcSrc = GL_ZERO;
 338         blendConfigs[10].funcDst = GL_ONE;
 339         blendConfigs[11].funcSrc = GL_ZERO;
 340         blendConfigs[11].funcDst = GL_ZERO;
 341
 342         std::vector<BlendConfig> configList(blendConfigs, blendConfigs + DE_LENGTH_OF_ARRAY(blendConfigs));
 343
 344         return configList;
 345 }
 346
 347 struct TestRenderPassConfig
 348 {
 349         TestRenderPassConfig            (void)
 350                 : testFunction                  (false) {}
 351
 352         TestRenderPassConfig            (const TextureSourcesType textureSourcesTypeValue,
 353                                                                 FBOConfig fboConfigListValue,
 354                                                                 const FramebufferSRGB framebufferSRGBValue,
 355                                                                 const FramebufferBlend framebufferBendValue,
 356                                                                 const RendererTask rendererTaskValue)
 357                 : textureSourcesType    (textureSourcesTypeValue)
 358                 , framebufferSRGB               (framebufferSRGBValue)
 359                 , frameBufferBlend              (framebufferBendValue)
 360                 , testFunction                  (false)
 361                 , rendererTask                  (rendererTaskValue) {fboConfigList.push_back(fboConfigListValue);}
 362
 363         TestRenderPassConfig            (const TextureSourcesType textureSourcesTypeValue,
 364                                                                 FBOConfig fboConfigListValue,
 365                                                                 const FramebufferSRGB framebufferSRGBValue,
 366                                                                 const FramebufferBlend framebufferBendValue,
 367                                                                 TestFunction testFunctionValue,
 368                                                                 const RendererTask rendererTaskValue)
 369                 : textureSourcesType    (textureSourcesTypeValue)
 370                 , framebufferSRGB               (framebufferSRGBValue)
 371                 , frameBufferBlend              (framebufferBendValue)
 372                 , testFunction                  (testFunctionValue)
 373                 , rendererTask                  (rendererTaskValue) {fboConfigList.push_back(fboConfigListValue);}
 374
 375         TestRenderPassConfig            (const TextureSourcesType textureSourcesTypeValue,
 376                                                                 std::vector<FBOConfig> fboConfigListValue,
 377                                                                 const FramebufferSRGB framebufferSRGBValue,
 378                                                                 const FramebufferBlend framebufferBendValue,
 379                                                                 TestFunction testFunctionValue,
 380                                                                 const RendererTask rendererTaskValue)
 381                 : textureSourcesType    (textureSourcesTypeValue)
 382                 , fboConfigList                 (fboConfigListValue)
 383                 , framebufferSRGB               (framebufferSRGBValue)
 384                 , frameBufferBlend              (framebufferBendValue)
 385                 , testFunction                  (testFunctionValue)
 386                 , rendererTask                  (rendererTaskValue) {}
 387
 388         ~TestRenderPassConfig           (void) {}
 389
 390         TextureSourcesType              textureSourcesType;
 391         std::vector<FBOConfig>  fboConfigList;
 392         FramebufferSRGB                 framebufferSRGB;
 393         FramebufferBlend                frameBufferBlend;
 394         TestFunction                    testFunction;
 395         RendererTask                    rendererTask;
 396 };
 397
 398 class TestVertexData
 399 {
 400 public:
 401                                                         TestVertexData          (Context& context);
 402                                                         ~TestVertexData         (void);
 403
 404         void                                    init                            (void);
 405
 406         void                                    bind                            (void) const;
 407         void                                    unbind                          (void) const;
 408
 409 private:
 410         const glw::Functions*   m_gl;
 411         std::vector<float>              m_data;
 412         glw::GLuint                             m_vboHandle;
 413         glw::GLuint                             m_vaoHandle;
 414 };
 415
 416 TestVertexData::TestVertexData  (Context& context)
 417         : m_gl                                          (&context.getRenderContext().getFunctions())
 418 {
 419         const glw::GLfloat              vertexData[]    =
 420         {
 421                 // position                             // texcoord
 422                 -1.0f, -1.0f, 0.0f,             0.0f, 0.0f, // bottom left corner
 423                  1.0f, -1.0f, 0.0f,             1.0f, 0.0f, // bottom right corner
 424                  1.0f,  1.0f, 0.0f,             1.0f, 1.0f, // Top right corner
 425
 426                 -1.0f,  1.0f, 0.0f,             0.0f, 1.0f, // top left corner
 427                  1.0f,  1.0f, 0.0f,             1.0f, 1.0f, // Top right corner
 428                 -1.0f, -1.0f, 0.0f,             0.0f, 0.0f  // bottom left corner
 429         };
 430
 431         m_data.resize(DE_LENGTH_OF_ARRAY(vertexData));
 432         for (int idx = 0; idx < (int)m_data.size(); idx++)
 433                 m_data[idx] = vertexData[idx];
 434
 435         m_gl->genVertexArrays(1, &m_vaoHandle);
 436         m_gl->bindVertexArray(m_vaoHandle);
 437
 438         m_gl->genBuffers(1, &m_vboHandle);
 439         m_gl->bindBuffer(GL_ARRAY_BUFFER, m_vboHandle);
 440
 441         m_gl->bufferData(GL_ARRAY_BUFFER, (glw::GLsizei)(m_data.size() * sizeof(glw::GLfloat)), &m_data[0], GL_STATIC_DRAW);
 442
 443         m_gl->enableVertexAttribArray(0);
 444         m_gl->vertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(GL_FLOAT), (glw::GLvoid *)0);
 445         m_gl->enableVertexAttribArray(1);
 446         m_gl->vertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, 5 * (glw::GLsizei)sizeof(GL_FLOAT), (glw::GLvoid *)(3 * sizeof(GL_FLOAT)));
 447
 448         m_gl->bindVertexArray(0);
 449         m_gl->bindBuffer(GL_ARRAY_BUFFER, 0);
 450         GLU_EXPECT_NO_ERROR(m_gl->getError(), "gl error during vertex data setup");
 451 }
 452
 453 TestVertexData::~TestVertexData (void)
 454 {
 455         m_gl->deleteBuffers(1, &m_vboHandle);
 456         m_gl->deleteVertexArrays(1, &m_vaoHandle);
 457 }
 458
 459 void TestVertexData::bind (void) const
 460 {
 461         m_gl->bindVertexArray(m_vaoHandle);
 462 }
 463
 464 void TestVertexData::unbind (void) const
 465 {
 466         m_gl->bindVertexArray(0);
 467 }
 468
 469 class TestTexture2D
 470 {
 471 public:
 472                                                                 TestTexture2D           (Context& context, const deUint32 internalFormatValue, const deUint32 transferFormatValue, const deUint32 transferTypeValue, const tcu::Vec4 imageColorValue, const int idx);
 473                                                                 ~TestTexture2D          (void);
 474
 475         int                                                     getTextureUnit          (void) const;
 476         deUint32                                        getHandle                       (void) const;
 477         int                                                     getIdx                          (void) const;
 478
 479         void                                            bind                            (const int textureUnit);
 480         void                                            unbind                          (void) const;
 481
 482 private:
 483         const glw::Functions*           m_gl;
 484         glw::GLuint                                     m_handle;
 485         const deUint32                          m_internalFormat;
 486         tcu::TextureFormat                      m_transferFormat;
 487         int                                                     m_width;
 488         int                                                     m_height;
 489         tcu::TextureLevel                       m_imageData;
 490         int                                                     m_textureUnit;
 491         const int                                       m_idx;
 492 };
 493
 494 TestTexture2D::TestTexture2D    (Context& context, const deUint32 internalFormat, const deUint32 transferFormat, const deUint32 transferType, const tcu::Vec4 imageColor, const int idx)
 495         : m_gl                                          (&context.getRenderContext().getFunctions())
 496         , m_internalFormat                      (internalFormat)
 497         , m_transferFormat                      (tcu::TextureFormat(glu::mapGLTransferFormat(transferFormat, transferType)))
 498         , m_width                                       (TestTextureSizes::WIDTH)
 499         , m_height                                      (TestTextureSizes::HEIGHT)
 500         , m_imageData                           (tcu::TextureLevel(glu::mapGLInternalFormat(internalFormat), m_width, m_height, 1))
 501         , m_idx                                         (idx)
 502 {
 503         // fill image data with a solid test color
 504         tcu::clear(m_imageData.getAccess(), tcu::Vec4(0.0f));
 505         for (int py = 0; py < m_imageData.getHeight(); py++)
 506         {
 507                 for (int px = 0; px < m_imageData.getWidth(); px++)
 508                         m_imageData.getAccess().setPixel(imageColor, px, py);
 509         }
 510
 511         m_gl->genTextures(1, &m_handle);
 512
 513         m_gl->bindTexture(GL_TEXTURE_2D, m_handle);
 514         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_WRAP_S,              GL_MIRRORED_REPEAT);
 515         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_WRAP_T,              GL_MIRRORED_REPEAT);
 516         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
 517         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
 518
 519         m_gl->texImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFormat, transferType, m_imageData.getAccess().getDataPtr());
 520
 521         m_gl->bindTexture(GL_TEXTURE_2D, 0);
 522 }
 523
 524 TestTexture2D::~TestTexture2D (void)
 525 {
 526         m_gl->deleteTextures(1, &m_handle);
 527 }
 528
 529 int TestTexture2D::getTextureUnit (void) const
 530 {
 531         return m_textureUnit;
 532 }
 533
 534 deUint32 TestTexture2D::getHandle (void) const
 535 {
 536         return m_handle;
 537 }
 538
 539 int TestTexture2D::getIdx (void) const
 540 {
 541         return m_idx;
 542 }
 543
 544 void TestTexture2D::bind (const int textureUnit)
 545 {
 546         m_textureUnit = textureUnit;
 547         m_gl->activeTexture(GL_TEXTURE0 + m_textureUnit);
 548         m_gl->bindTexture(GL_TEXTURE_2D, m_handle);
 549 }
 550
 551 void TestTexture2D::unbind (void) const
 552 {
 553         m_gl->bindTexture(GL_TEXTURE_2D, 0);
 554 }
 555
 556 class TestFramebuffer
 557 {
 558 public:
 559                                                                                                 TestFramebuffer                 (void);
 560                                                                                                 TestFramebuffer                 (Context& context, const deUint32 targetType, const deUint32 colorAttachment, glw::GLuint textureAttachmentHandle, const bool isSRGB, const FboType fboType, const int idx);
 561                                                                                                 ~TestFramebuffer                (void);
 562
 563         void                                                                            setTargetType                   (const deUint32 targetType);
 564
 565         FboType                                                                         getType                                 (void) const;
 566         deUint32                                                                        getHandle                               (void) const;
 567         deUint32                                                                        getColorAttachment              (void) const;
 568         int                                                                                     getIdx                                  (void) const;
 569         deUint32                                                                        getTargetType                   (void) const;
 570
 571         void                                                                            bind                                    (void);
 572         void                                                                            unbind                                  (void);
 573
 574         typedef de::UniquePtr<glu::Framebuffer>         fboUniquePtr;
 575
 576 private:
 577         const glw::Functions*                                           m_gl;
 578         fboUniquePtr                                                            m_referenceSource;
 579         deUint32                                                                        m_targetType;
 580         bool                                                                            m_bound;
 581         bool                                                                            m_isSRGB;
 582         FboType                                                                         m_type;
 583         const int                                                                       m_idx;
 584         deUint32                                                                        m_colorAttachment;
 585 };
 586
 587 TestFramebuffer::TestFramebuffer        (Context& context, const deUint32 targetType, const deUint32 colorAttachment, glw::GLuint textureAttachmentHandle, const bool isSRGB, const FboType fboType, const int idx)
 588         : m_gl                                                  (&context.getRenderContext().getFunctions())
 589         , m_referenceSource                             (new glu::Framebuffer(context.getRenderContext()))
 590         , m_targetType                                  (targetType)
 591         , m_bound                                               (false)
 592         , m_isSRGB                                              (isSRGB)
 593         , m_type                                                (fboType)
 594         , m_idx                                                 (idx)
 595         , m_colorAttachment                             (colorAttachment)
 596 {
 597         m_gl->bindFramebuffer(m_targetType, **m_referenceSource);
 598
 599         m_gl->framebufferTexture2D(m_targetType, m_colorAttachment, GL_TEXTURE_2D, textureAttachmentHandle, 0);
 600
 601         TCU_CHECK(m_gl->checkFramebufferStatus(m_targetType) == GL_FRAMEBUFFER_COMPLETE);
 602
 603         if (targetType == GL_DRAW_BUFFER)
 604         {
 605                 glw::GLuint textureAttachments[] = {m_colorAttachment};
 606                 m_gl->drawBuffers(DE_LENGTH_OF_ARRAY(textureAttachments), textureAttachments);
 607                 GLU_EXPECT_NO_ERROR(m_gl->getError(), "glDrawBuffer()");
 608         }
 609
 610         if (targetType == GL_READ_BUFFER)
 611         {
 612                 m_gl->readBuffer(m_colorAttachment);
 613                 GLU_EXPECT_NO_ERROR(m_gl->getError(), "glReadBuffer()");
 614         }
 615
 616         m_gl->bindFramebuffer(m_targetType, 0);
 617 }
 618
 619 TestFramebuffer::~TestFramebuffer (void)
 620 {
 621 }
 622
 623 void TestFramebuffer::setTargetType (const deUint32 targetType)
 624 {
 625         m_targetType = targetType;
 626 }
 627
 628 FboType TestFramebuffer::getType (void) const
 629 {
 630         return m_type;
 631 }
 632
 633 deUint32 TestFramebuffer::getHandle (void) const
 634 {
 635         return **m_referenceSource;
 636 }
 637
 638 deUint32 TestFramebuffer::getColorAttachment (void) const
 639 {
 640         return m_colorAttachment;
 641 }
 642
 643 int TestFramebuffer::getIdx (void) const
 644 {
 645         return m_idx;
 646 }
 647
 648 deUint32 TestFramebuffer::getTargetType (void) const
 649 {
 650         return m_targetType;
 651 }
 652
 653 void TestFramebuffer::bind (void)
 654 {
 655         if (!m_bound)
 656         {
 657                 m_gl->bindFramebuffer(m_targetType, **m_referenceSource);
 658                 m_bound = true;
 659         }
 660 }
 661
 662 void TestFramebuffer::unbind (void)
 663 {
 664         if (m_bound)
 665         {
 666                 m_gl->bindFramebuffer(m_targetType, 0);
 667                 m_bound = false;
 668         }
 669 }
 670
 671 class TestShaderProgram
 672 {
 673 public:
 674                                                                                 TestShaderProgram               (Context& context, const int samplerTotal, TestFunction testFunction);
 675                                                                                 ~TestShaderProgram              (void);
 676
 677         glw::GLuint                                                     getHandle                               (void) const;
 678         int                                                                     getSamplerTotal                 (void) const;
 679
 680         void                                                            use                                             (void) const;
 681         void                                                            unuse                                   (void) const;
 682
 683         glu::ShaderProgramInfo                          getLogInfo                              (void);
 684
 685 private:
 686         const glw::Functions*                           m_gl;
 687         de::MovePtr<glu::ShaderProgram>         m_referenceSource;
 688         const int                                                       m_samplerTotal;
 689         const int                                                       m_shaderStagesTotal;
 690 };
 691
 692 TestShaderProgram::TestShaderProgram    (Context& context, const int samplerTotal, TestFunction testFunction)
 693         : m_gl                                                          (&context.getRenderContext().getFunctions())
 694         , m_samplerTotal                                        (samplerTotal)
 695         , m_shaderStagesTotal                           (2)
 696 {
 697         std::ostringstream              shaderFragment;
 698
 699         const char* const shaderVertex =
 700                 "#version 310 es \n"
 701                 "layout (location = 0) in mediump vec3 aPosition; \n"
 702                 "layout (location = 1) in mediump vec2 aTexCoord; \n"
 703                 "out mediump vec2 vs_aTexCoord; \n"
 704                 "void main () \n"
 705                 "{ \n"
 706                 "       gl_Position = vec4(aPosition, 1.0f); \n"
 707                 "       vs_aTexCoord = aTexCoord; \n"
 708                 "} \n";
 709
 710         shaderFragment
 711                 << "#version 310 es \n"
 712                 << "in mediump vec2 vs_aTexCoord; \n"
 713                 << "layout (location = 0) out mediump vec4 fs_aColor0; \n";
 714
 715         for (int samplerIdx = 0; samplerIdx < m_samplerTotal; samplerIdx++)
 716                 shaderFragment
 717                         << "uniform sampler2D uTexture" << samplerIdx << "; \n";
 718
 719         shaderFragment
 720                 << "uniform int uFunctionType; \n";
 721
 722         if (testFunction.hasFunction)
 723                 shaderFragment
 724                 << "uniform int uBlendFunctionType; \n"
 725                 << "uniform mediump float uFactorSrc; \n"
 726                 << "uniform mediump float uFactorDst; \n"
 727                         << testFunction.functionDefintion;
 728
 729         shaderFragment
 730                 << "void main () \n"
 731                 << "{ \n";
 732
 733         for (int samplerIdx = 0; samplerIdx < m_samplerTotal; samplerIdx++)
 734                 shaderFragment
 735                         <<"     mediump vec4 texelColor" << samplerIdx << " = vec4(0.0f, 0.0f, 0.0f, 1.0f); \n";
 736
 737         shaderFragment
 738                 << buildSamplingPassType(m_samplerTotal);
 739
 740         if (testFunction.hasFunction)
 741                 shaderFragment
 742                         << "    fs_aColor0 = " << testFunction.functionName << "(texelColor0, texelColor1); \n";
 743         else
 744                 shaderFragment
 745                         << "    fs_aColor0 = texelColor0; \n";
 746
 747         shaderFragment
 748                 << "} \n";
 749
 750         m_referenceSource = de::MovePtr<glu::ShaderProgram>(new glu::ShaderProgram(context.getRenderContext(), glu::makeVtxFragSources(shaderVertex, shaderFragment.str())));
 751         if (!m_referenceSource->isOk())
 752         {
 753                 tcu::TestLog& log = context.getTestContext().getLog();
 754                 log << this->getLogInfo();
 755                 TCU_FAIL("Failed to compile shaders and link program");
 756         }
 757 }
 758
 759 TestShaderProgram::~TestShaderProgram (void)
 760 {
 761         m_referenceSource = de::MovePtr<glu::ShaderProgram>(DE_NULL);
 762         m_referenceSource.clear();
 763 }
 764
 765 deUint32 TestShaderProgram::getHandle (void) const
 766 {
 767         return m_referenceSource->getProgram();
 768 }
 769
 770 int TestShaderProgram::getSamplerTotal (void) const
 771 {
 772         return m_samplerTotal;
 773 }
 774
 775 void TestShaderProgram::use (void) const
 776 {
 777         m_gl->useProgram(this->getHandle());
 778 }
 779
 780 void TestShaderProgram::unuse (void) const
 781 {
 782         m_gl->useProgram(0);
 783 }
 784
 785 glu::ShaderProgramInfo TestShaderProgram::getLogInfo (void)
 786 {
 787         glu::ShaderProgramInfo  buildInfo;
 788
 789         // log shader program info. Only vertex and fragment shaders included
 790         buildInfo.program = m_referenceSource->getProgramInfo();
 791         for (int shaderIdx = 0; shaderIdx < m_shaderStagesTotal; shaderIdx++)
 792         {
 793                 glu::ShaderInfo shaderInfo = m_referenceSource->getShaderInfo(static_cast<glu::ShaderType>(static_cast<int>(glu::SHADERTYPE_VERTEX) + static_cast<int>(shaderIdx)), 0);
 794                 buildInfo.shaders.push_back(shaderInfo);
 795         }
 796         return buildInfo;
 797 }
 798
 799 class Renderer
 800 {
 801 public:
 802                                                                                         Renderer                                                (Context& context);
 803                                                                                         ~Renderer                                               (void);
 804
 805         void                                                                    init                                                    (const TestRenderPassConfig& renderPassConfig, const int renderpass);
 806         void                                                                    deinit                                                  (void);
 807
 808         void                                                                    setSamplingType                                 (const SamplingType samplerIdx);
 809         void                                                                    setBlendIteration                               (const int blendIteration);
 810         void                                                                    setFramebufferBlend                             (const bool blend);
 811         void                                                                    setFramebufferSRGB                              (const bool sRGB);
 812
 813         std::vector<tcu::Vec4>                                  getResultsPreDraw                               (void) const;
 814         std::vector<tcu::Vec4>                                  getResultsPostDraw                              (void) const;
 815         int                                                                             getBlendConfigCount                             (void) const;
 816         glu::ShaderProgramInfo                                  getShaderProgramInfo                    (void);
 817
 818         void                                                                    copyFrameBufferTexture                  (const int srcPx, const int srcPy, const int dstPx, const int dstPy);
 819         void                                                                    draw                                                    (void);
 820         void                                                                    storeShaderProgramInfo                  (void);
 821         void                                                                    logShaderProgramInfo                    (void);
 822
 823         typedef de::SharedPtr<TestTexture2D>    TextureSp;
 824         typedef de::SharedPtr<TestFramebuffer>  FboSp;
 825
 826 private:
 827         void                                                                    createFBOwithColorAttachment    (const std::vector<FBOConfig> fboConfigList);
 828         void                                                                    setShaderProgramSamplingType    (const int samplerIdx);
 829         void                                                                    setShaderBlendFunctionType              (void);
 830         void                                                                    setShaderBlendSrcDstValues              (void);
 831         void                                                                    bindActiveTexturesSamplers              (void);
 832         void                                                                    bindAllRequiredSourceTextures   (const TextureSourcesType texturesRequired);
 833         void                                                                    unbindAllSourceTextures                 (void);
 834         void                                                                    bindFramebuffer                                 (const int framebufferIdx);
 835         void                                                                    unbindFramebuffer                               (const int framebufferIdx);
 836         void                                                                    enableFramebufferSRGB                   (void);
 837         void                                                                    enableFramebufferBlend                  (void);
 838         bool                                                                    isFramebufferAttachmentSRGB             (const deUint32 targetType, const deUint32 attachment) const;
 839         void                                                                    readTexels                                              (const int px, const int py, const deUint32 attachment, tcu::Vec4& texelData);
 840         void                                                                    logState                                                (const deUint32 targetType, const deUint32 attachment, const SamplingType samplingType) const;
 841
 842         // renderer specific constants initialized during constructor
 843         Context&                                                                m_context;
 844         const TestVertexData                                    m_vertexData;
 845         const int                                                               m_textureSourceTotal;
 846
 847         // additional resources monitored by the renderer
 848         std::vector<BlendConfig>                                m_blendConfigList;
 849         std::vector<TextureSp>                                  m_textureSourceList;
 850         TestRenderPassConfig                                    m_renderPassConfig;
 851         std::vector<TextureSp>                                  m_fboTextureList;
 852         TestShaderProgram*                                              m_shaderProgram;
 853         std::vector<FboSp>                                              m_framebufferList;
 854         std::vector<tcu::Vec4>                                  m_resultsListPreDraw;
 855         std::vector<tcu::Vec4>                                  m_resultsListPostDraw;
 856
 857         // mutable state variables (internal access only)
 858         bool                                                                    m_hasShaderProgramInfo;
 859         int                                                                             m_renderPass;
 860         int                                                                             m_samplersRequired;
 861         bool                                                                    m_hasFunction;
 862         bool                                                                    m_blittingEnabled;
 863         glu::ShaderProgramInfo                                  m_shaderProgramInfo;
 864
 865         // mutable state variables (external access via setters)
 866         SamplingType                                                    m_samplingType;
 867         int                                                                             m_blendIteration;
 868         bool                                                                    m_framebufferBlendEnabled;
 869         bool                                                                    m_framebufferSRGBEnabled;
 870 };
 871
 872 Renderer::Renderer                              (Context& context)
 873         : m_context                                     (context)
 874         , m_vertexData                          (context)
 875         , m_textureSourceTotal          (2)
 876         , m_blendConfigList                     (getBlendingConfigList())
 877         , m_hasShaderProgramInfo        (false)
 878 {
 879         TextureSp textureLinear(new TestTexture2D(m_context, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, getTestColorLinear(), 0));
 880         m_textureSourceList.push_back(textureLinear);
 881
 882         TextureSp textureSRGB(new TestTexture2D(m_context, GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, getTestColorLinear(), 1));
 883         m_textureSourceList.push_back(textureSRGB);
 884 }
 885
 886 Renderer::~Renderer (void)
 887 {
 888         m_textureSourceList.clear();
 889         this->deinit();
 890 }
 891
 892 void Renderer::init (const TestRenderPassConfig& renderPassConfig, const int renderpass)
 893 {
 894         m_renderPassConfig = renderPassConfig;
 895         m_renderPass = renderpass;
 896
 897         this->createFBOwithColorAttachment(m_renderPassConfig.fboConfigList);
 898
 899         if (m_renderPassConfig.textureSourcesType != TEXTURESOURCESTYPE_NONE)
 900         {
 901                 if (m_renderPassConfig.textureSourcesType == TEXTURESOURCESTYPE_RGBA || m_renderPassConfig.textureSourcesType == TEXTURESOURCESTYPE_SRGBA)
 902                         m_samplersRequired = 1;
 903                 else if (m_renderPassConfig.textureSourcesType ==TEXTURESOURCESTYPE_BOTH )
 904                         m_samplersRequired = 2;
 905                 else
 906                         DE_FATAL("Error: Texture source required not recognised");
 907
 908                 m_shaderProgram = new TestShaderProgram(m_context, m_samplersRequired, m_renderPassConfig.testFunction);
 909                 m_hasFunction = m_renderPassConfig.testFunction.hasFunction;
 910         }
 911         else
 912                 m_shaderProgram = DE_NULL;
 913 }
 914
 915 void Renderer::deinit (void)
 916 {
 917         if (m_shaderProgram != DE_NULL)
 918         {
 919                 delete m_shaderProgram;
 920                 m_shaderProgram = DE_NULL;
 921         }
 922
 923         m_fboTextureList.clear();
 924         m_framebufferList.clear();
 925 }
 926
 927 void Renderer::setSamplingType (const SamplingType samplingType)
 928 {
 929         m_samplingType = samplingType;
 930 }
 931
 932 void Renderer::setBlendIteration (const int blendIteration)
 933 {
 934         m_blendIteration = blendIteration;
 935 }
 936
 937 void Renderer::setFramebufferBlend (const bool blend)
 938 {
 939         m_framebufferBlendEnabled = blend;
 940 }
 941
 942 void Renderer::setFramebufferSRGB (const bool sRGB)
 943 {
 944         m_framebufferSRGBEnabled = sRGB;
 945 }
 946
 947 std::vector<tcu::Vec4> Renderer::getResultsPreDraw (void) const
 948 {
 949         return m_resultsListPreDraw;
 950 }
 951
 952 std::vector<tcu::Vec4> Renderer::getResultsPostDraw (void) const
 953 {
 954         return m_resultsListPostDraw;
 955 }
 956
 957 int Renderer::getBlendConfigCount (void) const
 958 {
 959         return (int)m_blendConfigList.size();
 960 }
 961
 962 void Renderer::copyFrameBufferTexture (const int srcPx, const int srcPy, const int dstPx, const int dstPy)
 963 {
 964         const glw::Functions&   gl                                              = m_context.getRenderContext().getFunctions();
 965         int                                             fboSrcIdx                               = -1;
 966         int                                             fboDstIdx                               = -1;
 967         deUint32                                fboSrcColAttachment             = GL_NONE;
 968         deUint32                                fboDstColAttachment             = GL_NONE;
 969
 970         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
 971                 this->bindFramebuffer(idx);
 972
 973         // cache fbo attachments and idx locations
 974         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
 975         {
 976                 if (m_framebufferList[idx]->getType() == FBOTYPE_SOURCE)
 977                 {
 978                         fboSrcIdx = m_framebufferList[idx]->getIdx();
 979                         fboSrcColAttachment = m_framebufferList[fboSrcIdx]->getColorAttachment();
 980                 }
 981                 if (m_framebufferList[idx]->getType() == FBOTYPE_DESTINATION)
 982                 {
 983                         fboDstIdx = m_framebufferList[idx]->getIdx();
 984                         fboDstColAttachment = m_framebufferList[fboDstIdx]->getColorAttachment();
 985                 }
 986         }
 987
 988         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
 989                 m_framebufferList[idx]->unbind();
 990
 991         // store texel data from both src and dst before performing the copy
 992         m_resultsListPreDraw.resize(2);
 993         m_framebufferList[fboSrcIdx]->bind();
 994         this->readTexels(0, 0, fboSrcColAttachment, m_resultsListPreDraw[0]);
 995         m_framebufferList[fboSrcIdx]->unbind();
 996         m_framebufferList[fboDstIdx]->setTargetType(GL_READ_FRAMEBUFFER);
 997         m_framebufferList[fboDstIdx]->bind();
 998         this->readTexels(0, 0, fboDstColAttachment, m_resultsListPreDraw[1]);
 999         m_framebufferList[fboDstIdx]->unbind();
1000         m_framebufferList[fboDstIdx]->setTargetType(GL_DRAW_FRAMEBUFFER);
1001
1002         m_framebufferList[fboSrcIdx]->bind();
1003         m_framebufferList[fboDstIdx]->bind();
1004
1005         this->enableFramebufferSRGB();
1006         this->enableFramebufferBlend();
1007
1008         gl.blitFramebuffer(     srcPx, srcPy, TestTextureSizes::WIDTH, TestTextureSizes::HEIGHT,
1009                                                 dstPx, dstPy, TestTextureSizes::WIDTH, TestTextureSizes::HEIGHT,
1010                                                 GL_COLOR_BUFFER_BIT, GL_NEAREST);
1011
1012         m_resultsListPostDraw.resize(2);
1013         this->readTexels(0, 0, fboSrcColAttachment, m_resultsListPostDraw[0]);
1014         m_framebufferList[fboSrcIdx]->unbind();
1015         m_framebufferList[fboDstIdx]->unbind();
1016
1017         m_framebufferList[fboDstIdx]->setTargetType(GL_READ_FRAMEBUFFER);
1018         m_framebufferList[fboDstIdx]->bind();
1019         this->readTexels(0, 0, fboDstColAttachment, m_resultsListPostDraw[1]);
1020         m_framebufferList[fboDstIdx]->unbind();
1021 }
1022
1023 void Renderer::draw (void)
1024 {
1025         const glw::Functions&   gl = m_context.getRenderContext().getFunctions();
1026
1027         if (m_renderPassConfig.textureSourcesType == TEXTURESOURCESTYPE_NONE)
1028                 DE_FATAL("Error: Attempted to draw with no texture sources");
1029
1030         // resize results storage with each render pass
1031         m_resultsListPreDraw.resize(m_renderPass + 1);
1032         m_resultsListPostDraw.resize(m_renderPass + 1);
1033
1034         m_shaderProgram->use();
1035         m_vertexData.bind();
1036
1037         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
1038                 this->bindFramebuffer(idx);
1039
1040         this->bindAllRequiredSourceTextures(m_renderPassConfig.textureSourcesType);
1041         this->bindActiveTexturesSamplers();
1042
1043         this->enableFramebufferSRGB();
1044         this->enableFramebufferBlend();
1045
1046         this->readTexels(0, 0, GL_COLOR_ATTACHMENT0, m_resultsListPreDraw[m_renderPass]);
1047         this->setShaderProgramSamplingType(m_samplingType);
1048         if (m_hasFunction)
1049         {
1050                 this->setShaderBlendFunctionType();
1051                 this->setShaderBlendSrcDstValues();
1052         }
1053
1054         gl.drawArrays(GL_TRIANGLES, 0, 6);
1055
1056         this->readTexels(0, 0, GL_COLOR_ATTACHMENT0, m_resultsListPostDraw[m_renderPass]);
1057         this->logState(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_samplingType);
1058
1059         this->unbindAllSourceTextures();
1060         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
1061                 this->unbindFramebuffer(idx);
1062         m_vertexData.unbind();
1063         m_shaderProgram->unuse();
1064 }
1065
1066 void Renderer::storeShaderProgramInfo (void)
1067 {
1068         m_shaderProgramInfo = m_shaderProgram->getLogInfo();
1069         m_hasShaderProgramInfo = true;
1070 }
1071
1072 void Renderer::logShaderProgramInfo (void)
1073 {
1074         tcu::TestLog& log = m_context.getTestContext().getLog();
1075
1076         if (m_hasShaderProgramInfo)
1077                 log << m_shaderProgramInfo;
1078 }
1079
1080 void Renderer::createFBOwithColorAttachment (const std::vector<FBOConfig> fboConfigList)
1081 {
1082         const int size = (int)fboConfigList.size();
1083         for (int idx = 0; idx < size; idx++)
1084         {
1085                 TextureSp texture(new TestTexture2D(m_context, fboConfigList[idx].textureInternalFormat, GL_RGBA, GL_UNSIGNED_BYTE, fboConfigList[idx].textureColor, idx));
1086                 m_fboTextureList.push_back(texture);
1087
1088                 bool isSRGB;
1089                 if (fboConfigList[idx].textureInternalFormat == GL_SRGB8_ALPHA8)
1090                         isSRGB = true;
1091                 else
1092                         isSRGB = false;
1093
1094                 FboSp framebuffer(new TestFramebuffer(m_context, fboConfigList[idx].fboTargetType, fboConfigList[idx].fboColorAttachment, texture->getHandle(), isSRGB, fboConfigList[idx].fboType, idx));
1095                 m_framebufferList.push_back(framebuffer);
1096         }
1097 }
1098
1099 void Renderer::setShaderProgramSamplingType (const int samplerIdx)
1100 {
1101         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1102
1103         glw::GLuint location = gl.getUniformLocation(m_shaderProgram->getHandle(), "uFunctionType");
1104         DE_ASSERT(location != (glw::GLuint)-1);
1105         gl.uniform1i(location, samplerIdx);
1106 }
1107
1108 void Renderer::setShaderBlendFunctionType (void)
1109 {
1110         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1111
1112         int function = -1;
1113         if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_ADD)
1114                 function = 0;
1115         else if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_SUBTRACT)
1116                 function = 1;
1117         else if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_REVERSE_SUBTRACT)
1118                 function = 2;
1119         else
1120                 DE_FATAL("Error: Blend function not recognised");
1121
1122         glw::GLuint location = gl.getUniformLocation(m_shaderProgram->getHandle(), "uBlendFunctionType");
1123         DE_ASSERT(location != (glw::GLuint)-1);
1124         gl.uniform1i(location, function);
1125 }
1126
1127 void Renderer::setShaderBlendSrcDstValues (void)
1128 {
1129         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1130
1131         float funcSrc;
1132         if (m_blendConfigList[m_blendIteration].funcSrc == GL_ONE)
1133                 funcSrc = 1.0f;
1134         else
1135                 funcSrc = 0.0f;
1136
1137         float funcDst;
1138                 if (m_blendConfigList[m_blendIteration].funcDst == GL_ONE)
1139                 funcDst = 1.0f;
1140         else
1141                 funcDst = 0.0f;
1142
1143         glw::GLuint locationSrc = gl.getUniformLocation(m_shaderProgram->getHandle(), "uFactorSrc");
1144         gl.uniform1f(locationSrc, funcSrc);
1145         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1f()");
1146
1147         glw::GLuint locationDst = gl.getUniformLocation(m_shaderProgram->getHandle(), "uFactorDst");
1148         gl.uniform1f(locationDst, funcDst);
1149         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1f()");
1150 }
1151
1152 void Renderer::bindActiveTexturesSamplers (void)
1153 {
1154         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1155
1156         for (int idx = 0; idx < m_samplersRequired; idx++)
1157         {
1158                 std::ostringstream stream;
1159                 stream << "uTexture" << idx;
1160                 std::string uniformName(stream.str());
1161                 glw::GLint location = gl.getUniformLocation(m_shaderProgram->getHandle(), uniformName.c_str());
1162                 DE_ASSERT(location != -1);
1163                 gl.uniform1i(location, m_textureSourceList[idx]->getTextureUnit());
1164                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1165         }
1166 }
1167
1168 void Renderer::bindAllRequiredSourceTextures (const TextureSourcesType texturesRequired)
1169 {
1170         if (texturesRequired == TEXTURESOURCESTYPE_RGBA)
1171                 m_textureSourceList[0]->bind(0);
1172         else if (texturesRequired == TEXTURESOURCESTYPE_SRGBA)
1173                 m_textureSourceList[1]->bind(0);
1174         else if (texturesRequired == TEXTURESOURCESTYPE_BOTH)
1175         {
1176                 m_textureSourceList[0]->bind(0);
1177                 m_textureSourceList[1]->bind(1);
1178         }
1179         else
1180                 DE_FATAL("Error: Invalid sources requested in bind all");
1181 }
1182
1183 void Renderer::unbindAllSourceTextures (void)
1184 {
1185         for (int idx = 0; idx < (int)m_textureSourceList.size(); idx++)
1186                 m_textureSourceList[idx]->unbind();
1187 }
1188
1189 void Renderer::bindFramebuffer (const int framebufferIdx)
1190 {
1191         m_framebufferList[framebufferIdx]->bind();
1192 }
1193
1194 void Renderer::unbindFramebuffer (const int framebufferIdx)
1195 {
1196         m_framebufferList[framebufferIdx]->unbind();
1197 }
1198
1199 void Renderer::enableFramebufferSRGB (void)
1200 {
1201         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1202
1203         if (m_framebufferSRGBEnabled)
1204                 gl.enable(GL_FRAMEBUFFER_SRGB);
1205         else
1206                 gl.disable(GL_FRAMEBUFFER_SRGB);
1207 }
1208
1209 void Renderer::enableFramebufferBlend (void)
1210 {
1211         const glw::Functions&   gl      = m_context.getRenderContext().getFunctions();
1212         tcu::TestLog&                   log     = m_context.getTestContext().getLog();
1213         std::ostringstream              message;
1214
1215         message << "Blend settings = ";
1216
1217         if (m_framebufferBlendEnabled)
1218         {
1219                 gl.enable(GL_BLEND);
1220                 gl.blendEquation(m_blendConfigList[m_blendIteration].equation);
1221                 gl.blendFunc(m_blendConfigList[m_blendIteration].funcSrc, m_blendConfigList[m_blendIteration].funcDst);
1222
1223                 std::string equation, src, dst;
1224                 if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_ADD)
1225                         equation = "GL_FUNC_ADD";
1226                 if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_SUBTRACT)
1227                         equation = "GL_FUNC_SUBTRACT";
1228                 if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_REVERSE_SUBTRACT)
1229                         equation = "GL_FUNC_REVERSE_SUBTRACT";
1230                 if (m_blendConfigList[m_blendIteration].funcSrc == GL_ONE)
1231                         src = "GL_ONE";
1232                 else
1233                         src = "GL_ZERO";
1234                 if (m_blendConfigList[m_blendIteration].funcDst == GL_ONE)
1235                         dst = "GL_ONE";
1236                 else
1237                         dst = "GL_ZERO";
1238
1239                 message << "Enabled: equation = " << equation << ", func src = " << src << ", func dst = " << dst;
1240         }
1241         else
1242         {
1243                 gl.disable(GL_BLEND);
1244                 message << "Disabled";
1245         }
1246
1247         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1248 }
1249
1250 bool Renderer::isFramebufferAttachmentSRGB (const deUint32 targetType, const deUint32 attachment) const
1251 {
1252         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
1253         glw::GLint                              encodingType;
1254
1255         gl.getFramebufferAttachmentParameteriv(targetType, attachment, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &encodingType);
1256         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetNamedFramebufferAttachmentParameteriv()");
1257
1258         switch (static_cast<glw::GLenum>(encodingType))
1259         {
1260                 case GL_SRGB:
1261                 {
1262                         return true;
1263                         break;
1264                 }
1265                 case GL_LINEAR:
1266                 {
1267                         return false;
1268                         break;
1269                 }
1270                 default:
1271                 {
1272                         DE_FATAL("Error: Color attachment format not recognised");
1273                         return false;
1274                 }
1275         }
1276 }
1277
1278 void Renderer::readTexels (const int px, const int py, const deUint32 mode, tcu::Vec4& texelData)
1279 {
1280         const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
1281         tcu::TextureLevel               textureRead;
1282
1283         // ensure result sampling coordinates are within range of the result color attachment
1284         DE_ASSERT((px >= 0) && (px < m_context.getRenderTarget().getWidth()));
1285         DE_ASSERT((py >= 0) && (py < m_context.getRenderTarget().getHeight()));
1286
1287         gl.readBuffer(mode);
1288         textureRead.setStorage(glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE), TestTextureSizes::WIDTH, TestTextureSizes::HEIGHT);
1289         glu::readPixels(m_context.getRenderContext(), px, py, textureRead.getAccess());
1290         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
1291         texelData = textureRead.getAccess().getPixel(px, py);
1292 }
1293
1294 void Renderer::logState (const deUint32 targetType, const deUint32 attachment, const SamplingType samplingType) const
1295 {
1296         tcu::TestLog&                   log                                     = m_context.getTestContext().getLog();
1297         std::ostringstream              message;
1298
1299         bool fboAttachmentSRGB = this->isFramebufferAttachmentSRGB(targetType, attachment);
1300         message.str("");
1301         message << "getFramebufferAttachmentParameteriv() check = ";
1302         if (fboAttachmentSRGB)
1303                 message << "GL_SRGB";
1304         else
1305                 message << "GL_LINEAR";
1306         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1307
1308         message.str("");
1309         message << "Framebuffer color attachment value BEFORE draw call";
1310         logColor(m_context, message.str(), m_resultsListPreDraw[m_renderPass]);
1311
1312         message.str("");
1313         message << "Framebuffer color attachment value AFTER draw call";
1314         logColor(m_context, message.str(), m_resultsListPostDraw[m_renderPass]);
1315
1316         message.str("");
1317         message << "Sampling type = ";
1318         std::string type;
1319         if (samplingType == 0)
1320                 type = "texture()";
1321         else if (samplingType == 1)
1322                 type = "textureLOD()";
1323         else if (samplingType == 2)
1324                 type = "textureGrad()";
1325         else if (samplingType == 3)
1326                 type = "textureOffset()";
1327         else if (samplingType == 4)
1328                 type = "textureProj()";
1329         else
1330                 DE_FATAL("Error: Sampling type unregonised");
1331         message << type;
1332         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1333
1334         message.str("");
1335         if (m_framebufferSRGBEnabled)
1336                 message << "Framebuffer SRGB = enabled";
1337         else
1338                 message << "Framebuffer SRGB = disabled";
1339         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1340 }
1341
1342 class FboSRGBTestCase : public TestCase
1343 {
1344 public:
1345                                                                                         FboSRGBTestCase                         (Context& context, const char* const name, const char* const desc);
1346                                                                                         ~FboSRGBTestCase                        (void);
1347
1348         void                                                                    init                                            (void);
1349         void                                                                    deinit                                          (void);
1350         IterateResult                                                   iterate                                         (void);
1351
1352         void                                                                    setTestConfig                           (std::vector<TestRenderPassConfig> renderPassConfigList);
1353
1354         virtual void                                                    setupTest                                       (void) = 0;
1355         virtual bool                                                    verifyResult                            (void) = 0;
1356
1357 protected:
1358         bool                                                                    m_hasTestConfig;
1359         std::vector<TestRenderPassConfig>               m_renderPassConfigList;
1360         bool                                                                    m_testcaseRequiresBlend;
1361         std::vector<tcu::Vec4>                                  m_resultsPreDraw;
1362         std::vector<tcu::Vec4>                                  m_resultsPostDraw;
1363
1364 private:
1365                                                                                         FboSRGBTestCase                         (const FboSRGBTestCase&);
1366         FboSRGBTestCase&                                                operator=                                       (const FboSRGBTestCase&);
1367 };
1368
1369 FboSRGBTestCase::FboSRGBTestCase        (Context& context, const char* const name, const char* const desc)
1370         : TestCase                                              (context, name, desc)
1371         , m_hasTestConfig                               (false)
1372 {
1373 }
1374
1375 FboSRGBTestCase::~FboSRGBTestCase (void)
1376 {
1377         FboSRGBTestCase::deinit();
1378 }
1379
1380 void FboSRGBTestCase::init (void)
1381 {
1382         // extensions requirements for test
1383         if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1384                 TCU_THROW(NotSupportedError, "Test requires a context version equal or higher than 3.2");
1385
1386         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_sRGB_write_control"))
1387                 TCU_THROW(NotSupportedError, "Test requires extension GL_EXT_sRGB_write_control");
1388
1389         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_sRGB_decode"))
1390                 TCU_THROW(NotSupportedError, "Test requires GL_EXT_texture_sRGB_decode extension");
1391 }
1392
1393 void FboSRGBTestCase::deinit (void)
1394 {
1395 }
1396
1397 FboSRGBTestCase::IterateResult FboSRGBTestCase::iterate (void)
1398 {
1399         this->setupTest();
1400
1401         DE_ASSERT(m_hasTestConfig && "Error: Renderer was not supplied a test config");
1402
1403         Renderer renderer(m_context);
1404
1405         // loop through each sampling type
1406         for (int samplingIdx = 0; samplingIdx < SampligTypeCount::MAX; samplingIdx++)
1407         {
1408                 renderer.setSamplingType(static_cast<SamplingType>(samplingIdx));
1409
1410                 // loop through each blend configuration
1411                 const int blendCount = renderer.getBlendConfigCount();
1412                 for (int blendIdx = 0; blendIdx < blendCount; blendIdx++)
1413                 {
1414                         // loop through each render pass
1415                         const int renderPassCount = (int)m_renderPassConfigList.size();
1416                         for (int renderPassIdx = 0; renderPassIdx < renderPassCount; renderPassIdx++)
1417                         {
1418                                 TestRenderPassConfig renderPassConfig = m_renderPassConfigList[renderPassIdx];
1419
1420                                 renderer.init(renderPassConfig, renderPassIdx);
1421
1422                                 if (blendIdx == 0 && renderPassConfig.rendererTask == RENDERERTASK_DRAW)
1423                                         renderer.storeShaderProgramInfo();
1424
1425                                 if (renderPassConfig.frameBufferBlend == FRAMEBUFFERBLEND_ENABLED)
1426                                 {
1427                                         renderer.setBlendIteration(blendIdx);
1428                                         renderer.setFramebufferBlend(true);
1429                                 }
1430                                 else
1431                                         renderer.setFramebufferBlend(false);
1432
1433                                 if (renderPassConfig.framebufferSRGB == FRAMEBUFFERSRGB_ENABLED)
1434                                         renderer.setFramebufferSRGB(true);
1435                                 else
1436                                         renderer.setFramebufferSRGB(false);
1437
1438                                 if (renderPassConfig.rendererTask == RENDERERTASK_DRAW)
1439                                         renderer.draw();
1440                                 else if (renderPassConfig.rendererTask == RENDERERTASK_COPY)
1441                                         renderer.copyFrameBufferTexture(0, 0, 0, 0);
1442                                 else
1443                                         DE_FATAL("Error: render task not recognised");
1444
1445                                 renderer.deinit();
1446
1447                         } // render passes
1448
1449                         m_resultsPreDraw = renderer.getResultsPreDraw();
1450                         m_resultsPostDraw = renderer.getResultsPostDraw();
1451
1452                         bool testPassed = this->verifyResult();
1453                         if (testPassed)
1454                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1455                         else
1456                         {
1457                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result verification failed");
1458                                 renderer.logShaderProgramInfo();
1459                                 return STOP;
1460                         }
1461
1462                         if (!m_testcaseRequiresBlend)
1463                                 break;
1464                 } // blend configs
1465
1466                 renderer.logShaderProgramInfo();
1467         } // sampling types
1468
1469         return STOP;
1470 }
1471
1472 void FboSRGBTestCase::setTestConfig (std::vector<TestRenderPassConfig> renderPassConfigList)
1473 {
1474         m_renderPassConfigList = renderPassConfigList;
1475         m_hasTestConfig = true;
1476
1477         for (int idx = 0; idx < (int)renderPassConfigList.size(); idx++)
1478         {
1479                 if (renderPassConfigList[idx].frameBufferBlend == FRAMEBUFFERBLEND_ENABLED)
1480                 {
1481                         m_testcaseRequiresBlend = true;
1482                         return;
1483                 }
1484         }
1485         m_testcaseRequiresBlend = false;
1486 }
1487
1488 class FboSRGBQueryCase : public TestCase
1489 {
1490 public:
1491                                         FboSRGBQueryCase        (Context& context, const char* const name, const char* const description);
1492                                         ~FboSRGBQueryCase       (void);
1493
1494         void                    init                            (void);
1495         void                    deinit                          (void);
1496         IterateResult   iterate                         (void);
1497 };
1498
1499 FboSRGBQueryCase::FboSRGBQueryCase      (Context& context, const char* const name, const char* const description)
1500         : TestCase                                              (context, name, description)
1501 {
1502 }
1503
1504 FboSRGBQueryCase::~FboSRGBQueryCase (void)
1505 {
1506         FboSRGBQueryCase::deinit();
1507 }
1508
1509 void FboSRGBQueryCase::init (void)
1510 {
1511         // extension requirements for test
1512         if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) && !m_context.getContextInfo().isExtensionSupported("GL_EXT_sRGB_write_control"))
1513                 TCU_THROW(NotSupportedError, "Test requires extension GL_EXT_sRGB_write_control or a context version equal or higher than 3.2");
1514 }
1515
1516 void FboSRGBQueryCase::deinit (void)
1517 {
1518 }
1519
1520 FboSRGBQueryCase::IterateResult FboSRGBQueryCase::iterate (void)
1521 {
1522         // TEST INFO:
1523         // API tests which check when querying FRAMEBUFFER_SRGB_EXT capability returns the correct information when using glEnabled() or glDisabled()
1524
1525         const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
1526         tcu::TestLog&                   log             = m_context.getTestContext().getLog();
1527         const char*     const           msgPart = ", after disabling = ";
1528
1529         for (int idx = 0; idx < static_cast<int>(QUERYTYPE_LAST); idx++)
1530         {
1531                 std::ostringstream      message;
1532                 bool                            pass            = false;
1533
1534                 message << std::string("Results: After Enabling = ");
1535
1536                 gl.enable(GL_FRAMEBUFFER_SRGB);
1537
1538                 switch (static_cast<QueryType>(idx))
1539                 {
1540                         case QUERYTYPE_ISENABLED:
1541                         {
1542                                 glw::GLboolean enabled[2];
1543                                 enabled[0] = gl.isEnabled(GL_FRAMEBUFFER_SRGB);
1544                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1545                                 enabled[1] = gl.isEnabled(GL_FRAMEBUFFER_SRGB);
1546
1547                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1548                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1549                                 break;
1550                         }
1551                         case QUERYTYPE_BOOLEAN:
1552                         {
1553                                 glw::GLboolean enabled[2];
1554                                 gl.getBooleanv(GL_FRAMEBUFFER_SRGB,&enabled[0]);
1555                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1556                                 gl.getBooleanv(GL_FRAMEBUFFER_SRGB,&enabled[1]);
1557
1558                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1559                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1560                                 break;
1561                         }
1562                         case QUERYTYPE_FLOAT:
1563                         {
1564                                 glw::GLfloat enabled[2];
1565                                 gl.getFloatv(GL_FRAMEBUFFER_SRGB, &enabled[0]);
1566                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1567                                 gl.getFloatv(GL_FRAMEBUFFER_SRGB, &enabled[1]);
1568
1569                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1570                                 pass = ((int)enabled[0] && !((int)enabled[1])) ? true : false;
1571                                 break;
1572                         }
1573                         case QUERYTYPE_INT:
1574                         {
1575                                 glw::GLint enabled[2];
1576                                 gl.getIntegerv(GL_FRAMEBUFFER_SRGB, &enabled[0]);
1577                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1578                                 gl.getIntegerv(GL_FRAMEBUFFER_SRGB, &enabled[1]);
1579
1580                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1581                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1582                                 break;
1583                         }
1584                         case QUERYTYPE_INT64:
1585                         {
1586                                 glw::GLint64 enabled[2];
1587                                 gl.getInteger64v(GL_FRAMEBUFFER_SRGB, &enabled[0]);
1588                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1589                                 gl.getInteger64v(GL_FRAMEBUFFER_SRGB, &enabled[1]);
1590
1591                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1592                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1593                                 break;
1594                         }
1595                         default:
1596                                 DE_FATAL("Error: Datatype not recognised");
1597                 }
1598
1599                 log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1600
1601                 if (pass)
1602                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1603                 else
1604                 {
1605                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result verification failed");
1606                         return STOP;
1607                 }
1608         }
1609         return STOP;
1610 }
1611
1612 class FboSRGBColAttachCase : public FboSRGBTestCase
1613 {
1614 public:
1615                         FboSRGBColAttachCase    (Context& context, const char* const name, const char* const description)
1616                                 : FboSRGBTestCase       (context, name, description) {}
1617                         ~FboSRGBColAttachCase   (void) {}
1618
1619         void    setupTest                               (void);
1620         bool    verifyResult                    (void);
1621 };
1622
1623 void FboSRGBColAttachCase::setupTest (void)
1624 {
1625         // TEST INFO:
1626         // Check if FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING  set to SRGB and FRAMEBUFFER_SRGB_EXT enabled, destination colors are converted from SRGB to linear
1627         // before and after blending, finally the result is converted back to SRGB for storage
1628
1629         // NOTE:
1630         // if fbo pre-draw color set to linaer, color values get linearlized "twice"
1631         // (0.2f, 0.3f, 0.4f, 1.0f) when sampled i.e. converted in shader = (0.0331048f, 0.073239f, 0.132868f)
1632         // resulting in the follolwing blending equation (0.2f, 0.3f, 0.4f 1.0f) + (0.0331048, 0.073239, 0.132868) = (0.521569f, 0.647059f, 0.756863f, 1.0f)
1633
1634         FBOConfig fboConfig0 = FBOConfig(GL_SRGB8_ALPHA8, getTestColorLinear(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_SOURCE);
1635         FBOConfig fboConfig1 = FBOConfig(GL_RGBA8, getTestColorLinear(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_SOURCE);
1636
1637         const TestRenderPassConfig renderPassConfigs[] =
1638         {
1639                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_ENABLED, FRAMEBUFFERBLEND_ENABLED, RENDERERTASK_DRAW),
1640                 TestRenderPassConfig(TEXTURESOURCESTYPE_BOTH, fboConfig1, FRAMEBUFFERSRGB_DISABLED, FRAMEBUFFERBLEND_DISABLED, getFunctionBlendLinearToSRGBCheck(), RENDERERTASK_DRAW)
1641         };
1642         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1643
1644         this->setTestConfig(renderPassConfigList);
1645 }
1646
1647 bool FboSRGBColAttachCase::verifyResult (void)
1648 {
1649         if (tcu::boolAll(tcu::lessThan(tcu::abs(m_resultsPostDraw[0] - m_resultsPostDraw[1]), getEpsilonError())) || tcu::boolAll(tcu::equal(m_resultsPostDraw[0], m_resultsPostDraw[1])))
1650                 return true;
1651         else
1652                 return false;
1653 }
1654
1655 class FboSRGBToggleBlendCase : public FboSRGBTestCase
1656 {
1657 public:
1658                         FboSRGBToggleBlendCase          (Context& context, const char* const name, const char* const description)
1659                                 : FboSRGBTestCase               (context, name, description) {}
1660                         ~FboSRGBToggleBlendCase         (void) {}
1661
1662         void    setupTest                                       (void);
1663         bool    verifyResult                            (void);
1664 };
1665
1666 void FboSRGBToggleBlendCase::setupTest (void)
1667 {
1668         //      TEST INFO:
1669         //      Test to check if changing FRAMEBUFFER_SRGB_EXT from enabled to disabled. Enabled should produce SRGB color whilst disabled
1670         //      should produce linear color. Test conducted with blending disabled.
1671
1672         FBOConfig fboConfig0 = FBOConfig(GL_SRGB8_ALPHA8, getTestColorLinear(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_DESTINATION);
1673
1674         const TestRenderPassConfig renderPassConfigs[] =
1675         {
1676                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_ENABLED,  FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_DRAW),
1677                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_DISABLED, FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_DRAW)
1678         };
1679         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1680
1681         this->setTestConfig(renderPassConfigList);
1682 }
1683
1684 bool FboSRGBToggleBlendCase::verifyResult (void)
1685 {
1686         if (tcu::boolAny(tcu::greaterThan(tcu::abs(m_resultsPostDraw[0] - m_resultsPostDraw[1]), getEpsilonError())))
1687                 return true;
1688         else
1689                 return false;
1690 }
1691
1692 class FboSRGBRenderTargetIgnoreCase : public FboSRGBTestCase
1693 {
1694 public:
1695                         FboSRGBRenderTargetIgnoreCase           (Context& context, const char* const name, const char* const description)
1696                                 : FboSRGBTestCase                               (context, name, description) {}
1697                         ~FboSRGBRenderTargetIgnoreCase          (void) {}
1698
1699         void    setupTest                                                       (void);
1700         bool    verifyResult                                            (void);
1701 };
1702
1703 void FboSRGBRenderTargetIgnoreCase::setupTest (void)
1704 {
1705         // TEST INFO:
1706         // Check if render targets that are non-RGB ignore the state of GL_FRAMEBUFFER_SRGB_EXT. Rendering to an fbo with non-sRGB color
1707         // attachment should ignore color space conversion, producing linear color.
1708
1709         FBOConfig fboConfig0 = FBOConfig(GL_RGBA8, getTestColorBlank(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_DESTINATION);
1710
1711         const TestRenderPassConfig renderPassConfigs[] =
1712         {
1713                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_ENABLED,  FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_DRAW)
1714
1715         };
1716         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1717
1718         this->setTestConfig(renderPassConfigList);
1719 }
1720
1721 bool FboSRGBRenderTargetIgnoreCase::verifyResult (void)
1722 {
1723         if (tcu::boolAll(tcu::lessThan(tcu::abs(m_resultsPostDraw[0] - getTestColorLinear()), getEpsilonError())) || tcu::boolAll(tcu::equal(m_resultsPostDraw[0], getTestColorLinear())))
1724                 return true;
1725         else
1726                 return false;
1727 }
1728
1729 class FboSRGBCopyToLinearCase : public FboSRGBTestCase
1730 {
1731 public:
1732                         FboSRGBCopyToLinearCase         (Context& context, const char* const name, const char* const description)
1733                                 : FboSRGBTestCase               (context, name, description) {}
1734                         ~FboSRGBCopyToLinearCase        (void) {}
1735
1736         void    setupTest                                       (void);
1737         bool    verifyResult                            (void);
1738 };
1739
1740 void FboSRGBCopyToLinearCase::setupTest (void)
1741 {
1742         // TEST INFO:
1743         // Check if copying from an fbo with an sRGB color attachment to an fbo with a linear color attachment with FRAMEBUFFER_EXT enabled results in
1744         // an sRGB to linear conversion
1745
1746         FBOConfig fboConfigs[] =
1747         {
1748                 FBOConfig(GL_SRGB8_ALPHA8, getTestColorSRGB(), GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_SOURCE),
1749                 FBOConfig(GL_RGBA8, getTestColorBlank(), GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_DESTINATION)
1750         };
1751         std::vector<FBOConfig> fboConfigList(fboConfigs, fboConfigs + DE_LENGTH_OF_ARRAY(fboConfigs));
1752
1753         const TestRenderPassConfig renderPassConfigs[] =
1754         {
1755                 TestRenderPassConfig(TEXTURESOURCESTYPE_NONE, fboConfigList, FRAMEBUFFERSRGB_ENABLED,  FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_COPY)
1756         };
1757         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1758
1759         this->setTestConfig(renderPassConfigList);
1760 }
1761
1762 bool FboSRGBCopyToLinearCase::verifyResult (void)
1763 {
1764         logColor(m_context, "pre-copy source fbo color values", m_resultsPreDraw[0]);
1765         logColor(m_context, "pre-copy destination fbo color values", m_resultsPreDraw[1]);
1766         logColor(m_context, "post-copy source fbo color values", m_resultsPostDraw[0]);
1767         logColor(m_context, "post-copy destination fbo color values", m_resultsPostDraw[1]);
1768
1769         if (tcu::boolAll(tcu::lessThan(tcu::abs(m_resultsPostDraw[1] - getTestColorLinear()), getEpsilonError())) || tcu::boolAll(tcu::equal(m_resultsPostDraw[1], getTestColorLinear())))
1770                 return true;
1771         else
1772                 return false;
1773 }
1774
1775 class FboSRGBUnsupportedEnumCase : public TestCase
1776 {
1777 public:
1778                                         FboSRGBUnsupportedEnumCase      (Context& context, const char* const name, const char* const description);
1779                                         ~FboSRGBUnsupportedEnumCase     (void);
1780
1781         void                    init                                            (void);
1782         void                    deinit                                          (void);
1783         bool                    isInvalidEnum                           (std::string functionName);
1784         IterateResult   iterate                                         (void);
1785 };
1786
1787 FboSRGBUnsupportedEnumCase::FboSRGBUnsupportedEnumCase  (Context& context, const char* const name, const char* const description)
1788         : TestCase                                              (context, name, description)
1789 {
1790 }
1791
1792 FboSRGBUnsupportedEnumCase::~FboSRGBUnsupportedEnumCase (void)
1793 {
1794         FboSRGBUnsupportedEnumCase::deinit();
1795 }
1796
1797 void FboSRGBUnsupportedEnumCase::init (void)
1798 {
1799         // extension requirements for test
1800         if (glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)) || m_context.getContextInfo().isExtensionSupported("GL_EXT_sRGB_write_control"))
1801                 TCU_THROW(NotSupportedError, "Test requires extension GL_EXT_sRGB_write_control to be unsupported and a context version less than 3.2");
1802 }
1803
1804 void FboSRGBUnsupportedEnumCase::deinit (void)
1805 {
1806 }
1807
1808 bool FboSRGBUnsupportedEnumCase::isInvalidEnum (std::string functionName)
1809 {
1810         const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
1811         tcu::TestLog&                   log                     = m_context.getTestContext().getLog();
1812         bool                                    isOk            = true;
1813         glw::GLenum                             error           = GL_NO_ERROR;
1814
1815         log << tcu::TestLog::Message << "Checking call to " << functionName << tcu::TestLog::EndMessage;
1816
1817         error = gl.getError();
1818
1819         if (error != GL_INVALID_ENUM)
1820         {
1821                 log << tcu::TestLog::Message << " returned wrong value [" << glu::getErrorStr(error) << ", expected " << glu::getErrorStr(GL_INVALID_ENUM) << "]" << tcu::TestLog::EndMessage;
1822                 isOk = false;
1823         }
1824
1825         return isOk;
1826 }
1827
1828 FboSRGBUnsupportedEnumCase::IterateResult FboSRGBUnsupportedEnumCase::iterate (void)
1829 {
1830         // TEST INFO:
1831         // API tests that check calls using enum GL_FRAMEBUFFER_SRGB return GL_INVALID_ENUM  when GL_EXT_sRGB_write_control is not supported
1832
1833         const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
1834         bool                                    allPass         = true;
1835         glw::GLboolean                  bEnabled        = GL_FALSE;
1836         glw::GLfloat                    fEnabled        = 0;
1837         glw::GLint                              iEnabled        = 0;
1838         glw::GLint64                    lEnabled        = 0;
1839
1840         m_context.getTestContext().getLog() << tcu::TestLog::Message
1841                                                                                 << "Check calls using enum GL_FRAMEBUFFER_SRGB return GL_INVALID_ENUM  when GL_EXT_sRGB_write_control is not supported\n\n"
1842                                                                                 << tcu::TestLog::EndMessage;
1843
1844         gl.enable(GL_FRAMEBUFFER_SRGB);
1845         allPass &= isInvalidEnum("glEnable()");
1846
1847         gl.disable(GL_FRAMEBUFFER_SRGB);
1848         allPass &= isInvalidEnum("glDisable()");
1849
1850         gl.isEnabled(GL_FRAMEBUFFER_SRGB);
1851         allPass &= isInvalidEnum("glIsEnabled()");
1852
1853         gl.getBooleanv(GL_FRAMEBUFFER_SRGB, &bEnabled);
1854         allPass &= isInvalidEnum("glGetBooleanv()");
1855
1856         gl.getFloatv(GL_FRAMEBUFFER_SRGB, &fEnabled);
1857         allPass &= isInvalidEnum("glGetFloatv()");
1858
1859         gl.getIntegerv(GL_FRAMEBUFFER_SRGB, &iEnabled);
1860         allPass &= isInvalidEnum("glGetIntegerv()");
1861
1862         gl.getInteger64v(GL_FRAMEBUFFER_SRGB, &lEnabled);
1863         allPass &= isInvalidEnum("glGetInteger64v()");
1864
1865         if (allPass)
1866                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1867         else
1868                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1869
1870         return STOP;
1871 }
1872
1873 } // anonymous
1874
1875 FboSRGBWriteControlTests::FboSRGBWriteControlTests      (Context& context)
1876         : TestCaseGroup                 (context, "srgb_write_control", "Colorbuffer tests")
1877 {
1878 }
1879
1880 FboSRGBWriteControlTests::~FboSRGBWriteControlTests (void)
1881 {
1882 }
1883
1884 void FboSRGBWriteControlTests::init (void)
1885 {
1886         this->addChild(new FboSRGBQueryCase                                     (m_context, "framebuffer_srgb_enabled",                                                 "srgb enable framebuffer"));
1887         this->addChild(new FboSRGBColAttachCase                         (m_context, "framebuffer_srgb_enabled_col_attach",                              "srgb enable color attachment and framebuffer"));
1888         this->addChild(new FboSRGBToggleBlendCase                       (m_context, "framebuffer_srgb_enabled_blend",                                   "toggle framebuffer srgb settings with blend disabled"));
1889         this->addChild(new FboSRGBRenderTargetIgnoreCase        (m_context, "framebuffer_srgb_enabled_render_target_ignore",    "enable framebuffer srgb, non-srgb render target should ignore"));
1890         this->addChild(new FboSRGBCopyToLinearCase                      (m_context, "framebuffer_srgb_enabled_copy_to_linear",                  "no conversion when blittering between framebuffer srgb and linear"));
1891
1892         // negative
1893         this->addChild(new FboSRGBUnsupportedEnumCase           (m_context, "framebuffer_srgb_unsupported_enum",                                "check error codes for query functions when extension is not supported"));
1894 }
1895
1896 }
1897 } // gles31
1898 } // deqp