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);
 473                                                                 ~TestTexture2D          (void);
 474
 475         int                                                     getTextureUnit          (void) const;
 476         deUint32                                        getHandle                       (void) const;
 477
 478         void                                            bind                            (const int textureUnit);
 479         void                                            unbind                          (void) const;
 480
 481 private:
 482         const glw::Functions*           m_gl;
 483         glw::GLuint                                     m_handle;
 484         const deUint32                          m_internalFormat;
 485         tcu::TextureFormat                      m_transferFormat;
 486         int                                                     m_width;
 487         int                                                     m_height;
 488         tcu::TextureLevel                       m_imageData;
 489         int                                                     m_textureUnit;
 490 };
 491
 492 TestTexture2D::TestTexture2D    (Context& context, const deUint32 internalFormat, const deUint32 transferFormat, const deUint32 transferType, const tcu::Vec4 imageColor)
 493         : m_gl                                          (&context.getRenderContext().getFunctions())
 494         , m_internalFormat                      (internalFormat)
 495         , m_transferFormat                      (tcu::TextureFormat(glu::mapGLTransferFormat(transferFormat, transferType)))
 496         , m_width                                       (TestTextureSizes::WIDTH)
 497         , m_height                                      (TestTextureSizes::HEIGHT)
 498         , m_imageData                           (tcu::TextureLevel(glu::mapGLInternalFormat(internalFormat), m_width, m_height, 1))
 499 {
 500         // fill image data with a solid test color
 501         tcu::clear(m_imageData.getAccess(), tcu::Vec4(0.0f));
 502         for (int py = 0; py < m_imageData.getHeight(); py++)
 503         {
 504                 for (int px = 0; px < m_imageData.getWidth(); px++)
 505                         m_imageData.getAccess().setPixel(imageColor, px, py);
 506         }
 507
 508         m_gl->genTextures(1, &m_handle);
 509
 510         m_gl->bindTexture(GL_TEXTURE_2D, m_handle);
 511         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_WRAP_S,              GL_MIRRORED_REPEAT);
 512         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_WRAP_T,              GL_MIRRORED_REPEAT);
 513         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
 514         m_gl->texParameteri(GL_TEXTURE_2D,      GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
 515
 516         m_gl->texImage2D(GL_TEXTURE_2D, 0, m_internalFormat, m_width, m_height, 0, transferFormat, transferType, m_imageData.getAccess().getDataPtr());
 517
 518         m_gl->bindTexture(GL_TEXTURE_2D, 0);
 519 }
 520
 521 TestTexture2D::~TestTexture2D (void)
 522 {
 523         m_gl->deleteTextures(1, &m_handle);
 524 }
 525
 526 int TestTexture2D::getTextureUnit (void) const
 527 {
 528         return m_textureUnit;
 529 }
 530
 531 deUint32 TestTexture2D::getHandle (void) const
 532 {
 533         return m_handle;
 534 }
 535
 536 void TestTexture2D::bind (const int textureUnit)
 537 {
 538         m_textureUnit = textureUnit;
 539         m_gl->activeTexture(GL_TEXTURE0 + m_textureUnit);
 540         m_gl->bindTexture(GL_TEXTURE_2D, m_handle);
 541 }
 542
 543 void TestTexture2D::unbind (void) const
 544 {
 545         m_gl->bindTexture(GL_TEXTURE_2D, 0);
 546 }
 547
 548 class TestFramebuffer
 549 {
 550 public:
 551                                                                                                 TestFramebuffer                 (void);
 552                                                                                                 TestFramebuffer                 (Context& context, const deUint32 targetType, const deUint32 colorAttachment, glw::GLuint textureAttachmentHandle, const bool isSRGB, const FboType fboType, const int idx);
 553                                                                                                 ~TestFramebuffer                (void);
 554
 555         void                                                                            setTargetType                   (const deUint32 targetType);
 556
 557         FboType                                                                         getType                                 (void) const;
 558         deUint32                                                                        getColorAttachment              (void) const;
 559         int                                                                                     getIdx                                  (void) const;
 560
 561         void                                                                            bind                                    (void);
 562         void                                                                            unbind                                  (void);
 563
 564         typedef de::UniquePtr<glu::Framebuffer>         fboUniquePtr;
 565
 566 private:
 567         const glw::Functions*                                           m_gl;
 568         fboUniquePtr                                                            m_referenceSource;
 569         deUint32                                                                        m_targetType;
 570         bool                                                                            m_bound;
 571         bool                                                                            m_isSRGB;
 572         FboType                                                                         m_type;
 573         const int                                                                       m_idx;
 574         deUint32                                                                        m_colorAttachment;
 575 };
 576
 577 TestFramebuffer::TestFramebuffer        (Context& context, const deUint32 targetType, const deUint32 colorAttachment, glw::GLuint textureAttachmentHandle, const bool isSRGB, const FboType fboType, const int idx)
 578         : m_gl                                                  (&context.getRenderContext().getFunctions())
 579         , m_referenceSource                             (new glu::Framebuffer(context.getRenderContext()))
 580         , m_targetType                                  (targetType)
 581         , m_bound                                               (false)
 582         , m_isSRGB                                              (isSRGB)
 583         , m_type                                                (fboType)
 584         , m_idx                                                 (idx)
 585         , m_colorAttachment                             (colorAttachment)
 586 {
 587         m_gl->bindFramebuffer(m_targetType, **m_referenceSource);
 588
 589         m_gl->framebufferTexture2D(m_targetType, m_colorAttachment, GL_TEXTURE_2D, textureAttachmentHandle, 0);
 590
 591         TCU_CHECK(m_gl->checkFramebufferStatus(m_targetType) == GL_FRAMEBUFFER_COMPLETE);
 592
 593         if (targetType == GL_DRAW_BUFFER)
 594         {
 595                 glw::GLuint textureAttachments[] = {m_colorAttachment};
 596                 m_gl->drawBuffers(DE_LENGTH_OF_ARRAY(textureAttachments), textureAttachments);
 597                 GLU_EXPECT_NO_ERROR(m_gl->getError(), "glDrawBuffer()");
 598         }
 599
 600         if (targetType == GL_READ_BUFFER)
 601         {
 602                 m_gl->readBuffer(m_colorAttachment);
 603                 GLU_EXPECT_NO_ERROR(m_gl->getError(), "glReadBuffer()");
 604         }
 605
 606         m_gl->bindFramebuffer(m_targetType, 0);
 607 }
 608
 609 TestFramebuffer::~TestFramebuffer (void)
 610 {
 611 }
 612
 613 void TestFramebuffer::setTargetType (const deUint32 targetType)
 614 {
 615         m_targetType = targetType;
 616 }
 617
 618 FboType TestFramebuffer::getType (void) const
 619 {
 620         return m_type;
 621 }
 622
 623 deUint32 TestFramebuffer::getColorAttachment (void) const
 624 {
 625         return m_colorAttachment;
 626 }
 627
 628 int TestFramebuffer::getIdx (void) const
 629 {
 630         return m_idx;
 631 }
 632
 633 void TestFramebuffer::bind (void)
 634 {
 635         if (!m_bound)
 636         {
 637                 m_gl->bindFramebuffer(m_targetType, **m_referenceSource);
 638                 m_bound = true;
 639         }
 640 }
 641
 642 void TestFramebuffer::unbind (void)
 643 {
 644         if (m_bound)
 645         {
 646                 m_gl->bindFramebuffer(m_targetType, 0);
 647                 m_bound = false;
 648         }
 649 }
 650
 651 class TestShaderProgram
 652 {
 653 public:
 654                                                                                 TestShaderProgram               (Context& context, const int samplerTotal, TestFunction testFunction);
 655                                                                                 ~TestShaderProgram              (void);
 656
 657         glw::GLuint                                                     getHandle                               (void) const;
 658
 659         void                                                            use                                             (void) const;
 660         void                                                            unuse                                   (void) const;
 661
 662         glu::ShaderProgramInfo                          getLogInfo                              (void);
 663
 664 private:
 665         const glw::Functions*                           m_gl;
 666         de::MovePtr<glu::ShaderProgram>         m_referenceSource;
 667         const int                                                       m_samplerTotal;
 668         const int                                                       m_shaderStagesTotal;
 669 };
 670
 671 TestShaderProgram::TestShaderProgram    (Context& context, const int samplerTotal, TestFunction testFunction)
 672         : m_gl                                                          (&context.getRenderContext().getFunctions())
 673         , m_samplerTotal                                        (samplerTotal)
 674         , m_shaderStagesTotal                           (2)
 675 {
 676         std::ostringstream              shaderFragment;
 677
 678         const char* const shaderVertex =
 679                 "#version 310 es \n"
 680                 "layout (location = 0) in mediump vec3 aPosition; \n"
 681                 "layout (location = 1) in mediump vec2 aTexCoord; \n"
 682                 "out mediump vec2 vs_aTexCoord; \n"
 683                 "void main () \n"
 684                 "{ \n"
 685                 "       gl_Position = vec4(aPosition, 1.0f); \n"
 686                 "       vs_aTexCoord = aTexCoord; \n"
 687                 "} \n";
 688
 689         shaderFragment
 690                 << "#version 310 es \n"
 691                 << "in mediump vec2 vs_aTexCoord; \n"
 692                 << "layout (location = 0) out mediump vec4 fs_aColor0; \n";
 693
 694         for (int samplerIdx = 0; samplerIdx < m_samplerTotal; samplerIdx++)
 695                 shaderFragment
 696                         << "uniform sampler2D uTexture" << samplerIdx << "; \n";
 697
 698         shaderFragment
 699                 << "uniform int uFunctionType; \n";
 700
 701         if (testFunction.hasFunction)
 702                 shaderFragment
 703                 << "uniform int uBlendFunctionType; \n"
 704                 << "uniform mediump float uFactorSrc; \n"
 705                 << "uniform mediump float uFactorDst; \n"
 706                         << testFunction.functionDefintion;
 707
 708         shaderFragment
 709                 << "void main () \n"
 710                 << "{ \n";
 711
 712         for (int samplerIdx = 0; samplerIdx < m_samplerTotal; samplerIdx++)
 713                 shaderFragment
 714                         <<"     mediump vec4 texelColor" << samplerIdx << " = vec4(0.0f, 0.0f, 0.0f, 1.0f); \n";
 715
 716         shaderFragment
 717                 << buildSamplingPassType(m_samplerTotal);
 718
 719         if (testFunction.hasFunction)
 720                 shaderFragment
 721                         << "    fs_aColor0 = " << testFunction.functionName << "(texelColor0, texelColor1); \n";
 722         else
 723                 shaderFragment
 724                         << "    fs_aColor0 = texelColor0; \n";
 725
 726         shaderFragment
 727                 << "} \n";
 728
 729         m_referenceSource = de::MovePtr<glu::ShaderProgram>(new glu::ShaderProgram(context.getRenderContext(), glu::makeVtxFragSources(shaderVertex, shaderFragment.str())));
 730         if (!m_referenceSource->isOk())
 731         {
 732                 tcu::TestLog& log = context.getTestContext().getLog();
 733                 log << this->getLogInfo();
 734                 TCU_FAIL("Failed to compile shaders and link program");
 735         }
 736 }
 737
 738 TestShaderProgram::~TestShaderProgram (void)
 739 {
 740         m_referenceSource = de::MovePtr<glu::ShaderProgram>(DE_NULL);
 741         m_referenceSource.clear();
 742 }
 743
 744 deUint32 TestShaderProgram::getHandle (void) const
 745 {
 746         return m_referenceSource->getProgram();
 747 }
 748
 749 void TestShaderProgram::use (void) const
 750 {
 751         m_gl->useProgram(this->getHandle());
 752 }
 753
 754 void TestShaderProgram::unuse (void) const
 755 {
 756         m_gl->useProgram(0);
 757 }
 758
 759 glu::ShaderProgramInfo TestShaderProgram::getLogInfo (void)
 760 {
 761         glu::ShaderProgramInfo  buildInfo;
 762
 763         // log shader program info. Only vertex and fragment shaders included
 764         buildInfo.program = m_referenceSource->getProgramInfo();
 765         for (int shaderIdx = 0; shaderIdx < m_shaderStagesTotal; shaderIdx++)
 766         {
 767                 glu::ShaderInfo shaderInfo = m_referenceSource->getShaderInfo(static_cast<glu::ShaderType>(static_cast<int>(glu::SHADERTYPE_VERTEX) + static_cast<int>(shaderIdx)), 0);
 768                 buildInfo.shaders.push_back(shaderInfo);
 769         }
 770         return buildInfo;
 771 }
 772
 773 class Renderer
 774 {
 775 public:
 776                                                                                         Renderer                                                (Context& context);
 777                                                                                         ~Renderer                                               (void);
 778
 779         void                                                                    init                                                    (const TestRenderPassConfig& renderPassConfig, const int renderpass);
 780         void                                                                    deinit                                                  (void);
 781
 782         void                                                                    setSamplingType                                 (const SamplingType samplerIdx);
 783         void                                                                    setBlendIteration                               (const int blendIteration);
 784         void                                                                    setFramebufferBlend                             (const bool blend);
 785         void                                                                    setFramebufferSRGB                              (const bool sRGB);
 786
 787         std::vector<tcu::Vec4>                                  getResultsPreDraw                               (void) const;
 788         std::vector<tcu::Vec4>                                  getResultsPostDraw                              (void) const;
 789         int                                                                             getBlendConfigCount                             (void) const;
 790         glu::ShaderProgramInfo                                  getShaderProgramInfo                    (void);
 791
 792         void                                                                    copyFrameBufferTexture                  (const int srcPx, const int srcPy, const int dstPx, const int dstPy);
 793         void                                                                    draw                                                    (void);
 794         void                                                                    storeShaderProgramInfo                  (void);
 795         void                                                                    logShaderProgramInfo                    (void);
 796
 797         typedef de::SharedPtr<TestTexture2D>    TextureSp;
 798         typedef de::SharedPtr<TestFramebuffer>  FboSp;
 799
 800 private:
 801         void                                                                    createFBOwithColorAttachment    (const std::vector<FBOConfig> fboConfigList);
 802         void                                                                    setShaderProgramSamplingType    (const int samplerIdx);
 803         void                                                                    setShaderBlendFunctionType              (void);
 804         void                                                                    setShaderBlendSrcDstValues              (void);
 805         void                                                                    bindActiveTexturesSamplers              (void);
 806         void                                                                    bindAllRequiredSourceTextures   (const TextureSourcesType texturesRequired);
 807         void                                                                    unbindAllSourceTextures                 (void);
 808         void                                                                    bindFramebuffer                                 (const int framebufferIdx);
 809         void                                                                    unbindFramebuffer                               (const int framebufferIdx);
 810         void                                                                    enableFramebufferSRGB                   (void);
 811         void                                                                    enableFramebufferBlend                  (void);
 812         bool                                                                    isFramebufferAttachmentSRGB             (const deUint32 targetType, const deUint32 attachment) const;
 813         void                                                                    readTexels                                              (const int px, const int py, const deUint32 attachment, tcu::Vec4& texelData);
 814         void                                                                    logState                                                (const deUint32 targetType, const deUint32 attachment, const SamplingType samplingType) const;
 815
 816         // renderer specific constants initialized during constructor
 817         Context&                                                                m_context;
 818         const TestVertexData                                    m_vertexData;
 819         const int                                                               m_textureSourceTotal;
 820
 821         // additional resources monitored by the renderer
 822         std::vector<BlendConfig>                                m_blendConfigList;
 823         std::vector<TextureSp>                                  m_textureSourceList;
 824         TestRenderPassConfig                                    m_renderPassConfig;
 825         std::vector<TextureSp>                                  m_fboTextureList;
 826         TestShaderProgram*                                              m_shaderProgram;
 827         std::vector<FboSp>                                              m_framebufferList;
 828         std::vector<tcu::Vec4>                                  m_resultsListPreDraw;
 829         std::vector<tcu::Vec4>                                  m_resultsListPostDraw;
 830
 831         // mutable state variables (internal access only)
 832         bool                                                                    m_hasShaderProgramInfo;
 833         int                                                                             m_renderPass;
 834         int                                                                             m_samplersRequired;
 835         bool                                                                    m_hasFunction;
 836         bool                                                                    m_blittingEnabled;
 837         glu::ShaderProgramInfo                                  m_shaderProgramInfo;
 838
 839         // mutable state variables (external access via setters)
 840         SamplingType                                                    m_samplingType;
 841         int                                                                             m_blendIteration;
 842         bool                                                                    m_framebufferBlendEnabled;
 843         bool                                                                    m_framebufferSRGBEnabled;
 844 };
 845
 846 Renderer::Renderer                              (Context& context)
 847         : m_context                                     (context)
 848         , m_vertexData                          (context)
 849         , m_textureSourceTotal          (2)
 850         , m_blendConfigList                     (getBlendingConfigList())
 851         , m_hasShaderProgramInfo        (false)
 852 {
 853         TextureSp textureLinear(new TestTexture2D(m_context, GL_RGBA8, GL_RGBA, GL_UNSIGNED_BYTE, getTestColorLinear()));
 854         m_textureSourceList.push_back(textureLinear);
 855
 856         TextureSp textureSRGB(new TestTexture2D(m_context, GL_SRGB8_ALPHA8, GL_RGBA, GL_UNSIGNED_BYTE, getTestColorLinear()));
 857         m_textureSourceList.push_back(textureSRGB);
 858 }
 859
 860 Renderer::~Renderer (void)
 861 {
 862         m_textureSourceList.clear();
 863         this->deinit();
 864 }
 865
 866 void Renderer::init (const TestRenderPassConfig& renderPassConfig, const int renderpass)
 867 {
 868         m_renderPassConfig = renderPassConfig;
 869         m_renderPass = renderpass;
 870
 871         this->createFBOwithColorAttachment(m_renderPassConfig.fboConfigList);
 872
 873         if (m_renderPassConfig.textureSourcesType != TEXTURESOURCESTYPE_NONE)
 874         {
 875                 if (m_renderPassConfig.textureSourcesType == TEXTURESOURCESTYPE_RGBA || m_renderPassConfig.textureSourcesType == TEXTURESOURCESTYPE_SRGBA)
 876                         m_samplersRequired = 1;
 877                 else if (m_renderPassConfig.textureSourcesType ==TEXTURESOURCESTYPE_BOTH )
 878                         m_samplersRequired = 2;
 879                 else
 880                         DE_FATAL("Error: Texture source required not recognised");
 881
 882                 m_shaderProgram = new TestShaderProgram(m_context, m_samplersRequired, m_renderPassConfig.testFunction);
 883                 m_hasFunction = m_renderPassConfig.testFunction.hasFunction;
 884         }
 885         else
 886                 m_shaderProgram = DE_NULL;
 887 }
 888
 889 void Renderer::deinit (void)
 890 {
 891         if (m_shaderProgram != DE_NULL)
 892         {
 893                 delete m_shaderProgram;
 894                 m_shaderProgram = DE_NULL;
 895         }
 896
 897         m_fboTextureList.clear();
 898         m_framebufferList.clear();
 899 }
 900
 901 void Renderer::setSamplingType (const SamplingType samplingType)
 902 {
 903         m_samplingType = samplingType;
 904 }
 905
 906 void Renderer::setBlendIteration (const int blendIteration)
 907 {
 908         m_blendIteration = blendIteration;
 909 }
 910
 911 void Renderer::setFramebufferBlend (const bool blend)
 912 {
 913         m_framebufferBlendEnabled = blend;
 914 }
 915
 916 void Renderer::setFramebufferSRGB (const bool sRGB)
 917 {
 918         m_framebufferSRGBEnabled = sRGB;
 919 }
 920
 921 std::vector<tcu::Vec4> Renderer::getResultsPreDraw (void) const
 922 {
 923         return m_resultsListPreDraw;
 924 }
 925
 926 std::vector<tcu::Vec4> Renderer::getResultsPostDraw (void) const
 927 {
 928         return m_resultsListPostDraw;
 929 }
 930
 931 int Renderer::getBlendConfigCount (void) const
 932 {
 933         return (int)m_blendConfigList.size();
 934 }
 935
 936 void Renderer::copyFrameBufferTexture (const int srcPx, const int srcPy, const int dstPx, const int dstPy)
 937 {
 938         const glw::Functions&   gl                                              = m_context.getRenderContext().getFunctions();
 939         int                                             fboSrcIdx                               = -1;
 940         int                                             fboDstIdx                               = -1;
 941         deUint32                                fboSrcColAttachment             = GL_NONE;
 942         deUint32                                fboDstColAttachment             = GL_NONE;
 943
 944         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
 945                 this->bindFramebuffer(idx);
 946
 947         // cache fbo attachments and idx locations
 948         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
 949         {
 950                 if (m_framebufferList[idx]->getType() == FBOTYPE_SOURCE)
 951                 {
 952                         fboSrcIdx = m_framebufferList[idx]->getIdx();
 953                         fboSrcColAttachment = m_framebufferList[fboSrcIdx]->getColorAttachment();
 954                 }
 955                 if (m_framebufferList[idx]->getType() == FBOTYPE_DESTINATION)
 956                 {
 957                         fboDstIdx = m_framebufferList[idx]->getIdx();
 958                         fboDstColAttachment = m_framebufferList[fboDstIdx]->getColorAttachment();
 959                 }
 960         }
 961
 962         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
 963                 m_framebufferList[idx]->unbind();
 964
 965         // store texel data from both src and dst before performing the copy
 966         m_resultsListPreDraw.resize(2);
 967         m_framebufferList[fboSrcIdx]->bind();
 968         this->readTexels(0, 0, fboSrcColAttachment, m_resultsListPreDraw[0]);
 969         m_framebufferList[fboSrcIdx]->unbind();
 970         m_framebufferList[fboDstIdx]->setTargetType(GL_READ_FRAMEBUFFER);
 971         m_framebufferList[fboDstIdx]->bind();
 972         this->readTexels(0, 0, fboDstColAttachment, m_resultsListPreDraw[1]);
 973         m_framebufferList[fboDstIdx]->unbind();
 974         m_framebufferList[fboDstIdx]->setTargetType(GL_DRAW_FRAMEBUFFER);
 975
 976         m_framebufferList[fboSrcIdx]->bind();
 977         m_framebufferList[fboDstIdx]->bind();
 978
 979         this->enableFramebufferSRGB();
 980         this->enableFramebufferBlend();
 981
 982         gl.blitFramebuffer(     srcPx, srcPy, TestTextureSizes::WIDTH, TestTextureSizes::HEIGHT,
 983                                                 dstPx, dstPy, TestTextureSizes::WIDTH, TestTextureSizes::HEIGHT,
 984                                                 GL_COLOR_BUFFER_BIT, GL_NEAREST);
 985
 986         m_resultsListPostDraw.resize(2);
 987         this->readTexels(0, 0, fboSrcColAttachment, m_resultsListPostDraw[0]);
 988         m_framebufferList[fboSrcIdx]->unbind();
 989         m_framebufferList[fboDstIdx]->unbind();
 990
 991         m_framebufferList[fboDstIdx]->setTargetType(GL_READ_FRAMEBUFFER);
 992         m_framebufferList[fboDstIdx]->bind();
 993         this->readTexels(0, 0, fboDstColAttachment, m_resultsListPostDraw[1]);
 994         m_framebufferList[fboDstIdx]->unbind();
 995 }
 996
 997 void Renderer::draw (void)
 998 {
 999         const glw::Functions&   gl = m_context.getRenderContext().getFunctions();
1000
1001         if (m_renderPassConfig.textureSourcesType == TEXTURESOURCESTYPE_NONE)
1002                 DE_FATAL("Error: Attempted to draw with no texture sources");
1003
1004         // resize results storage with each render pass
1005         m_resultsListPreDraw.resize(m_renderPass + 1);
1006         m_resultsListPostDraw.resize(m_renderPass + 1);
1007
1008         m_shaderProgram->use();
1009         m_vertexData.bind();
1010
1011         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
1012                 this->bindFramebuffer(idx);
1013
1014         this->bindAllRequiredSourceTextures(m_renderPassConfig.textureSourcesType);
1015         this->bindActiveTexturesSamplers();
1016
1017         this->enableFramebufferSRGB();
1018         this->enableFramebufferBlend();
1019
1020         this->readTexels(0, 0, GL_COLOR_ATTACHMENT0, m_resultsListPreDraw[m_renderPass]);
1021         this->setShaderProgramSamplingType(m_samplingType);
1022         if (m_hasFunction)
1023         {
1024                 this->setShaderBlendFunctionType();
1025                 this->setShaderBlendSrcDstValues();
1026         }
1027
1028         gl.drawArrays(GL_TRIANGLES, 0, 6);
1029
1030         this->readTexels(0, 0, GL_COLOR_ATTACHMENT0, m_resultsListPostDraw[m_renderPass]);
1031         this->logState(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_samplingType);
1032
1033         this->unbindAllSourceTextures();
1034         for (int idx = 0; idx < (int)m_framebufferList.size(); idx++)
1035                 this->unbindFramebuffer(idx);
1036         m_vertexData.unbind();
1037         m_shaderProgram->unuse();
1038 }
1039
1040 void Renderer::storeShaderProgramInfo (void)
1041 {
1042         m_shaderProgramInfo = m_shaderProgram->getLogInfo();
1043         m_hasShaderProgramInfo = true;
1044 }
1045
1046 void Renderer::logShaderProgramInfo (void)
1047 {
1048         tcu::TestLog& log = m_context.getTestContext().getLog();
1049
1050         if (m_hasShaderProgramInfo)
1051                 log << m_shaderProgramInfo;
1052 }
1053
1054 void Renderer::createFBOwithColorAttachment (const std::vector<FBOConfig> fboConfigList)
1055 {
1056         const int size = (int)fboConfigList.size();
1057         for (int idx = 0; idx < size; idx++)
1058         {
1059                 TextureSp texture(new TestTexture2D(m_context, fboConfigList[idx].textureInternalFormat, GL_RGBA, GL_UNSIGNED_BYTE, fboConfigList[idx].textureColor));
1060                 m_fboTextureList.push_back(texture);
1061
1062                 bool isSRGB;
1063                 if (fboConfigList[idx].textureInternalFormat == GL_SRGB8_ALPHA8)
1064                         isSRGB = true;
1065                 else
1066                         isSRGB = false;
1067
1068                 FboSp framebuffer(new TestFramebuffer(m_context, fboConfigList[idx].fboTargetType, fboConfigList[idx].fboColorAttachment, texture->getHandle(), isSRGB, fboConfigList[idx].fboType, idx));
1069                 m_framebufferList.push_back(framebuffer);
1070         }
1071 }
1072
1073 void Renderer::setShaderProgramSamplingType (const int samplerIdx)
1074 {
1075         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1076
1077         glw::GLuint location = gl.getUniformLocation(m_shaderProgram->getHandle(), "uFunctionType");
1078         DE_ASSERT(location != (glw::GLuint)-1);
1079         gl.uniform1i(location, samplerIdx);
1080 }
1081
1082 void Renderer::setShaderBlendFunctionType (void)
1083 {
1084         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1085
1086         int function = -1;
1087         if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_ADD)
1088                 function = 0;
1089         else if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_SUBTRACT)
1090                 function = 1;
1091         else if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_REVERSE_SUBTRACT)
1092                 function = 2;
1093         else
1094                 DE_FATAL("Error: Blend function not recognised");
1095
1096         glw::GLuint location = gl.getUniformLocation(m_shaderProgram->getHandle(), "uBlendFunctionType");
1097         DE_ASSERT(location != (glw::GLuint)-1);
1098         gl.uniform1i(location, function);
1099 }
1100
1101 void Renderer::setShaderBlendSrcDstValues (void)
1102 {
1103         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1104
1105         float funcSrc;
1106         if (m_blendConfigList[m_blendIteration].funcSrc == GL_ONE)
1107                 funcSrc = 1.0f;
1108         else
1109                 funcSrc = 0.0f;
1110
1111         float funcDst;
1112                 if (m_blendConfigList[m_blendIteration].funcDst == GL_ONE)
1113                 funcDst = 1.0f;
1114         else
1115                 funcDst = 0.0f;
1116
1117         glw::GLuint locationSrc = gl.getUniformLocation(m_shaderProgram->getHandle(), "uFactorSrc");
1118         gl.uniform1f(locationSrc, funcSrc);
1119         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1f()");
1120
1121         glw::GLuint locationDst = gl.getUniformLocation(m_shaderProgram->getHandle(), "uFactorDst");
1122         gl.uniform1f(locationDst, funcDst);
1123         GLU_EXPECT_NO_ERROR(gl.getError(), "glUniform1f()");
1124 }
1125
1126 void Renderer::bindActiveTexturesSamplers (void)
1127 {
1128         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1129
1130         for (int idx = 0; idx < m_samplersRequired; idx++)
1131         {
1132                 std::ostringstream stream;
1133                 stream << "uTexture" << idx;
1134                 std::string uniformName(stream.str());
1135                 glw::GLint location = gl.getUniformLocation(m_shaderProgram->getHandle(), uniformName.c_str());
1136                 DE_ASSERT(location != -1);
1137                 gl.uniform1i(location, m_textureSourceList[idx]->getTextureUnit());
1138                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetUniformLocation()");
1139         }
1140 }
1141
1142 void Renderer::bindAllRequiredSourceTextures (const TextureSourcesType texturesRequired)
1143 {
1144         if (texturesRequired == TEXTURESOURCESTYPE_RGBA)
1145                 m_textureSourceList[0]->bind(0);
1146         else if (texturesRequired == TEXTURESOURCESTYPE_SRGBA)
1147                 m_textureSourceList[1]->bind(0);
1148         else if (texturesRequired == TEXTURESOURCESTYPE_BOTH)
1149         {
1150                 m_textureSourceList[0]->bind(0);
1151                 m_textureSourceList[1]->bind(1);
1152         }
1153         else
1154                 DE_FATAL("Error: Invalid sources requested in bind all");
1155 }
1156
1157 void Renderer::unbindAllSourceTextures (void)
1158 {
1159         for (int idx = 0; idx < (int)m_textureSourceList.size(); idx++)
1160                 m_textureSourceList[idx]->unbind();
1161 }
1162
1163 void Renderer::bindFramebuffer (const int framebufferIdx)
1164 {
1165         m_framebufferList[framebufferIdx]->bind();
1166 }
1167
1168 void Renderer::unbindFramebuffer (const int framebufferIdx)
1169 {
1170         m_framebufferList[framebufferIdx]->unbind();
1171 }
1172
1173 void Renderer::enableFramebufferSRGB (void)
1174 {
1175         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
1176
1177         if (m_framebufferSRGBEnabled)
1178                 gl.enable(GL_FRAMEBUFFER_SRGB);
1179         else
1180                 gl.disable(GL_FRAMEBUFFER_SRGB);
1181 }
1182
1183 void Renderer::enableFramebufferBlend (void)
1184 {
1185         const glw::Functions&   gl      = m_context.getRenderContext().getFunctions();
1186         tcu::TestLog&                   log     = m_context.getTestContext().getLog();
1187         std::ostringstream              message;
1188
1189         message << "Blend settings = ";
1190
1191         if (m_framebufferBlendEnabled)
1192         {
1193                 gl.enable(GL_BLEND);
1194                 gl.blendEquation(m_blendConfigList[m_blendIteration].equation);
1195                 gl.blendFunc(m_blendConfigList[m_blendIteration].funcSrc, m_blendConfigList[m_blendIteration].funcDst);
1196
1197                 std::string equation, src, dst;
1198                 if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_ADD)
1199                         equation = "GL_FUNC_ADD";
1200                 if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_SUBTRACT)
1201                         equation = "GL_FUNC_SUBTRACT";
1202                 if (m_blendConfigList[m_blendIteration].equation == GL_FUNC_REVERSE_SUBTRACT)
1203                         equation = "GL_FUNC_REVERSE_SUBTRACT";
1204                 if (m_blendConfigList[m_blendIteration].funcSrc == GL_ONE)
1205                         src = "GL_ONE";
1206                 else
1207                         src = "GL_ZERO";
1208                 if (m_blendConfigList[m_blendIteration].funcDst == GL_ONE)
1209                         dst = "GL_ONE";
1210                 else
1211                         dst = "GL_ZERO";
1212
1213                 message << "Enabled: equation = " << equation << ", func src = " << src << ", func dst = " << dst;
1214         }
1215         else
1216         {
1217                 gl.disable(GL_BLEND);
1218                 message << "Disabled";
1219         }
1220
1221         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1222 }
1223
1224 bool Renderer::isFramebufferAttachmentSRGB (const deUint32 targetType, const deUint32 attachment) const
1225 {
1226         const glw::Functions&   gl                              = m_context.getRenderContext().getFunctions();
1227         glw::GLint                              encodingType;
1228
1229         gl.getFramebufferAttachmentParameteriv(targetType, attachment, GL_FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING, &encodingType);
1230         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetNamedFramebufferAttachmentParameteriv()");
1231
1232         switch (static_cast<glw::GLenum>(encodingType))
1233         {
1234                 case GL_SRGB:
1235                 {
1236                         return true;
1237                         break;
1238                 }
1239                 case GL_LINEAR:
1240                 {
1241                         return false;
1242                         break;
1243                 }
1244                 default:
1245                 {
1246                         DE_FATAL("Error: Color attachment format not recognised");
1247                         return false;
1248                 }
1249         }
1250 }
1251
1252 void Renderer::readTexels (const int px, const int py, const deUint32 mode, tcu::Vec4& texelData)
1253 {
1254         const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
1255         tcu::TextureLevel               textureRead;
1256
1257         // ensure result sampling coordinates are within range of the result color attachment
1258         DE_ASSERT((px >= 0) && (px < m_context.getRenderTarget().getWidth()));
1259         DE_ASSERT((py >= 0) && (py < m_context.getRenderTarget().getHeight()));
1260
1261         gl.readBuffer(mode);
1262         textureRead.setStorage(glu::mapGLTransferFormat(GL_RGBA, GL_UNSIGNED_BYTE), TestTextureSizes::WIDTH, TestTextureSizes::HEIGHT);
1263         glu::readPixels(m_context.getRenderContext(), px, py, textureRead.getAccess());
1264         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels()");
1265         texelData = textureRead.getAccess().getPixel(px, py);
1266 }
1267
1268 void Renderer::logState (const deUint32 targetType, const deUint32 attachment, const SamplingType samplingType) const
1269 {
1270         tcu::TestLog&                   log                                     = m_context.getTestContext().getLog();
1271         std::ostringstream              message;
1272
1273         bool fboAttachmentSRGB = this->isFramebufferAttachmentSRGB(targetType, attachment);
1274         message.str("");
1275         message << "getFramebufferAttachmentParameteriv() check = ";
1276         if (fboAttachmentSRGB)
1277                 message << "GL_SRGB";
1278         else
1279                 message << "GL_LINEAR";
1280         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1281
1282         message.str("");
1283         message << "Framebuffer color attachment value BEFORE draw call";
1284         logColor(m_context, message.str(), m_resultsListPreDraw[m_renderPass]);
1285
1286         message.str("");
1287         message << "Framebuffer color attachment value AFTER draw call";
1288         logColor(m_context, message.str(), m_resultsListPostDraw[m_renderPass]);
1289
1290         message.str("");
1291         message << "Sampling type = ";
1292         std::string type;
1293         if (samplingType == 0)
1294                 type = "texture()";
1295         else if (samplingType == 1)
1296                 type = "textureLOD()";
1297         else if (samplingType == 2)
1298                 type = "textureGrad()";
1299         else if (samplingType == 3)
1300                 type = "textureOffset()";
1301         else if (samplingType == 4)
1302                 type = "textureProj()";
1303         else
1304                 DE_FATAL("Error: Sampling type unregonised");
1305         message << type;
1306         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1307
1308         message.str("");
1309         if (m_framebufferSRGBEnabled)
1310                 message << "Framebuffer SRGB = enabled";
1311         else
1312                 message << "Framebuffer SRGB = disabled";
1313         log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1314 }
1315
1316 class FboSRGBTestCase : public TestCase
1317 {
1318 public:
1319                                                                                         FboSRGBTestCase                         (Context& context, const char* const name, const char* const desc);
1320                                                                                         ~FboSRGBTestCase                        (void);
1321
1322         void                                                                    init                                            (void);
1323         void                                                                    deinit                                          (void);
1324         IterateResult                                                   iterate                                         (void);
1325
1326         void                                                                    setTestConfig                           (std::vector<TestRenderPassConfig> renderPassConfigList);
1327
1328         virtual void                                                    setupTest                                       (void) = 0;
1329         virtual bool                                                    verifyResult                            (void) = 0;
1330
1331 protected:
1332         bool                                                                    m_hasTestConfig;
1333         std::vector<TestRenderPassConfig>               m_renderPassConfigList;
1334         bool                                                                    m_testcaseRequiresBlend;
1335         std::vector<tcu::Vec4>                                  m_resultsPreDraw;
1336         std::vector<tcu::Vec4>                                  m_resultsPostDraw;
1337
1338 private:
1339                                                                                         FboSRGBTestCase                         (const FboSRGBTestCase&);
1340         FboSRGBTestCase&                                                operator=                                       (const FboSRGBTestCase&);
1341 };
1342
1343 FboSRGBTestCase::FboSRGBTestCase        (Context& context, const char* const name, const char* const desc)
1344         : TestCase                                              (context, name, desc)
1345         , m_hasTestConfig                               (false)
1346 {
1347 }
1348
1349 FboSRGBTestCase::~FboSRGBTestCase (void)
1350 {
1351         FboSRGBTestCase::deinit();
1352 }
1353
1354 void FboSRGBTestCase::init (void)
1355 {
1356         // extensions requirements for test
1357         if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2)))
1358                 TCU_THROW(NotSupportedError, "Test requires a context version equal or higher than 3.2");
1359
1360         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_sRGB_write_control"))
1361                 TCU_THROW(NotSupportedError, "Test requires extension GL_EXT_sRGB_write_control");
1362
1363         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_texture_sRGB_decode"))
1364                 TCU_THROW(NotSupportedError, "Test requires GL_EXT_texture_sRGB_decode extension");
1365 }
1366
1367 void FboSRGBTestCase::deinit (void)
1368 {
1369 }
1370
1371 FboSRGBTestCase::IterateResult FboSRGBTestCase::iterate (void)
1372 {
1373         this->setupTest();
1374
1375         DE_ASSERT(m_hasTestConfig && "Error: Renderer was not supplied a test config");
1376
1377         Renderer renderer(m_context);
1378
1379         // loop through each sampling type
1380         for (int samplingIdx = 0; samplingIdx < SampligTypeCount::MAX; samplingIdx++)
1381         {
1382                 renderer.setSamplingType(static_cast<SamplingType>(samplingIdx));
1383
1384                 // loop through each blend configuration
1385                 const int blendCount = renderer.getBlendConfigCount();
1386                 for (int blendIdx = 0; blendIdx < blendCount; blendIdx++)
1387                 {
1388                         // loop through each render pass
1389                         const int renderPassCount = (int)m_renderPassConfigList.size();
1390                         for (int renderPassIdx = 0; renderPassIdx < renderPassCount; renderPassIdx++)
1391                         {
1392                                 TestRenderPassConfig renderPassConfig = m_renderPassConfigList[renderPassIdx];
1393
1394                                 renderer.init(renderPassConfig, renderPassIdx);
1395
1396                                 if (blendIdx == 0 && renderPassConfig.rendererTask == RENDERERTASK_DRAW)
1397                                         renderer.storeShaderProgramInfo();
1398
1399                                 if (renderPassConfig.frameBufferBlend == FRAMEBUFFERBLEND_ENABLED)
1400                                 {
1401                                         renderer.setBlendIteration(blendIdx);
1402                                         renderer.setFramebufferBlend(true);
1403                                 }
1404                                 else
1405                                         renderer.setFramebufferBlend(false);
1406
1407                                 if (renderPassConfig.framebufferSRGB == FRAMEBUFFERSRGB_ENABLED)
1408                                         renderer.setFramebufferSRGB(true);
1409                                 else
1410                                         renderer.setFramebufferSRGB(false);
1411
1412                                 if (renderPassConfig.rendererTask == RENDERERTASK_DRAW)
1413                                         renderer.draw();
1414                                 else if (renderPassConfig.rendererTask == RENDERERTASK_COPY)
1415                                         renderer.copyFrameBufferTexture(0, 0, 0, 0);
1416                                 else
1417                                         DE_FATAL("Error: render task not recognised");
1418
1419                                 renderer.deinit();
1420
1421                         } // render passes
1422
1423                         m_resultsPreDraw = renderer.getResultsPreDraw();
1424                         m_resultsPostDraw = renderer.getResultsPostDraw();
1425
1426                         bool testPassed = this->verifyResult();
1427                         if (testPassed)
1428                                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1429                         else
1430                         {
1431                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result verification failed");
1432                                 renderer.logShaderProgramInfo();
1433                                 return STOP;
1434                         }
1435
1436                         if (!m_testcaseRequiresBlend)
1437                                 break;
1438                 } // blend configs
1439
1440                 renderer.logShaderProgramInfo();
1441         } // sampling types
1442
1443         return STOP;
1444 }
1445
1446 void FboSRGBTestCase::setTestConfig (std::vector<TestRenderPassConfig> renderPassConfigList)
1447 {
1448         m_renderPassConfigList = renderPassConfigList;
1449         m_hasTestConfig = true;
1450
1451         for (int idx = 0; idx < (int)renderPassConfigList.size(); idx++)
1452         {
1453                 if (renderPassConfigList[idx].frameBufferBlend == FRAMEBUFFERBLEND_ENABLED)
1454                 {
1455                         m_testcaseRequiresBlend = true;
1456                         return;
1457                 }
1458         }
1459         m_testcaseRequiresBlend = false;
1460 }
1461
1462 class FboSRGBQueryCase : public TestCase
1463 {
1464 public:
1465                                         FboSRGBQueryCase        (Context& context, const char* const name, const char* const description);
1466                                         ~FboSRGBQueryCase       (void);
1467
1468         void                    init                            (void);
1469         void                    deinit                          (void);
1470         IterateResult   iterate                         (void);
1471 };
1472
1473 FboSRGBQueryCase::FboSRGBQueryCase      (Context& context, const char* const name, const char* const description)
1474         : TestCase                                              (context, name, description)
1475 {
1476 }
1477
1478 FboSRGBQueryCase::~FboSRGBQueryCase (void)
1479 {
1480         FboSRGBQueryCase::deinit();
1481 }
1482
1483 void FboSRGBQueryCase::init (void)
1484 {
1485         // extension requirements for test
1486         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_sRGB_write_control"))
1487                 TCU_THROW(NotSupportedError, "Test requires extension GL_EXT_sRGB_write_control");
1488 }
1489
1490 void FboSRGBQueryCase::deinit (void)
1491 {
1492 }
1493
1494 FboSRGBQueryCase::IterateResult FboSRGBQueryCase::iterate (void)
1495 {
1496         // TEST INFO:
1497         // API tests which check when querying FRAMEBUFFER_SRGB_EXT capability returns the correct information when using glEnabled() or glDisabled()
1498
1499         const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
1500         tcu::TestLog&                   log             = m_context.getTestContext().getLog();
1501         const char*     const           msgPart = ", after disabling = ";
1502
1503         for (int idx = 0; idx < static_cast<int>(QUERYTYPE_LAST); idx++)
1504         {
1505                 std::ostringstream      message;
1506                 bool                            pass            = false;
1507
1508                 message << std::string("Results: After Enabling = ");
1509
1510                 gl.enable(GL_FRAMEBUFFER_SRGB);
1511
1512                 switch (static_cast<QueryType>(idx))
1513                 {
1514                         case QUERYTYPE_ISENABLED:
1515                         {
1516                                 glw::GLboolean enabled[2];
1517                                 enabled[0] = gl.isEnabled(GL_FRAMEBUFFER_SRGB);
1518                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1519                                 enabled[1] = gl.isEnabled(GL_FRAMEBUFFER_SRGB);
1520
1521                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1522                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1523                                 break;
1524                         }
1525                         case QUERYTYPE_BOOLEAN:
1526                         {
1527                                 glw::GLboolean enabled[2];
1528                                 gl.getBooleanv(GL_FRAMEBUFFER_SRGB,&enabled[0]);
1529                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1530                                 gl.getBooleanv(GL_FRAMEBUFFER_SRGB,&enabled[1]);
1531
1532                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1533                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1534                                 break;
1535                         }
1536                         case QUERYTYPE_FLOAT:
1537                         {
1538                                 glw::GLfloat enabled[2];
1539                                 gl.getFloatv(GL_FRAMEBUFFER_SRGB, &enabled[0]);
1540                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1541                                 gl.getFloatv(GL_FRAMEBUFFER_SRGB, &enabled[1]);
1542
1543                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1544                                 pass = ((int)enabled[0] && !((int)enabled[1])) ? true : false;
1545                                 break;
1546                         }
1547                         case QUERYTYPE_INT:
1548                         {
1549                                 glw::GLint enabled[2];
1550                                 gl.getIntegerv(GL_FRAMEBUFFER_SRGB, &enabled[0]);
1551                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1552                                 gl.getIntegerv(GL_FRAMEBUFFER_SRGB, &enabled[1]);
1553
1554                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1555                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1556                                 break;
1557                         }
1558                         case QUERYTYPE_INT64:
1559                         {
1560                                 glw::GLint64 enabled[2];
1561                                 gl.getInteger64v(GL_FRAMEBUFFER_SRGB, &enabled[0]);
1562                                 gl.disable(GL_FRAMEBUFFER_SRGB);
1563                                 gl.getInteger64v(GL_FRAMEBUFFER_SRGB, &enabled[1]);
1564
1565                                 message << static_cast<float>(enabled[0]) << msgPart << static_cast<float>(enabled[1]);
1566                                 pass = (enabled[0] && !(enabled[1])) ? true : false;
1567                                 break;
1568                         }
1569                         default:
1570                                 DE_FATAL("Error: Datatype not recognised");
1571                 }
1572
1573                 log << tcu::TestLog::Message << message.str() << tcu::TestLog::EndMessage;
1574
1575                 if (pass)
1576                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1577                 else
1578                 {
1579                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Result verification failed");
1580                         return STOP;
1581                 }
1582         }
1583         return STOP;
1584 }
1585
1586 class FboSRGBColAttachCase : public FboSRGBTestCase
1587 {
1588 public:
1589                         FboSRGBColAttachCase    (Context& context, const char* const name, const char* const description)
1590                                 : FboSRGBTestCase       (context, name, description) {}
1591                         ~FboSRGBColAttachCase   (void) {}
1592
1593         void    setupTest                               (void);
1594         bool    verifyResult                    (void);
1595 };
1596
1597 void FboSRGBColAttachCase::setupTest (void)
1598 {
1599         // TEST INFO:
1600         // Check if FRAMEBUFFER_ATTACHMENT_COLOR_ENCODING  set to SRGB and FRAMEBUFFER_SRGB_EXT enabled, destination colors are converted from SRGB to linear
1601         // before and after blending, finally the result is converted back to SRGB for storage
1602
1603         // NOTE:
1604         // if fbo pre-draw color set to linaer, color values get linearlized "twice"
1605         // (0.2f, 0.3f, 0.4f, 1.0f) when sampled i.e. converted in shader = (0.0331048f, 0.073239f, 0.132868f)
1606         // 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)
1607
1608         FBOConfig fboConfig0 = FBOConfig(GL_SRGB8_ALPHA8, getTestColorLinear(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_SOURCE);
1609         FBOConfig fboConfig1 = FBOConfig(GL_RGBA8, getTestColorLinear(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_SOURCE);
1610
1611         const TestRenderPassConfig renderPassConfigs[] =
1612         {
1613                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_ENABLED, FRAMEBUFFERBLEND_ENABLED, RENDERERTASK_DRAW),
1614                 TestRenderPassConfig(TEXTURESOURCESTYPE_BOTH, fboConfig1, FRAMEBUFFERSRGB_DISABLED, FRAMEBUFFERBLEND_DISABLED, getFunctionBlendLinearToSRGBCheck(), RENDERERTASK_DRAW)
1615         };
1616         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1617
1618         this->setTestConfig(renderPassConfigList);
1619 }
1620
1621 bool FboSRGBColAttachCase::verifyResult (void)
1622 {
1623         if (tcu::boolAll(tcu::lessThan(tcu::abs(m_resultsPostDraw[0] - m_resultsPostDraw[1]), getEpsilonError())) || tcu::boolAll(tcu::equal(m_resultsPostDraw[0], m_resultsPostDraw[1])))
1624                 return true;
1625         else
1626                 return false;
1627 }
1628
1629 class FboSRGBToggleBlendCase : public FboSRGBTestCase
1630 {
1631 public:
1632                         FboSRGBToggleBlendCase          (Context& context, const char* const name, const char* const description)
1633                                 : FboSRGBTestCase               (context, name, description) {}
1634                         ~FboSRGBToggleBlendCase         (void) {}
1635
1636         void    setupTest                                       (void);
1637         bool    verifyResult                            (void);
1638 };
1639
1640 void FboSRGBToggleBlendCase::setupTest (void)
1641 {
1642         //      TEST INFO:
1643         //      Test to check if changing FRAMEBUFFER_SRGB_EXT from enabled to disabled. Enabled should produce SRGB color whilst disabled
1644         //      should produce linear color. Test conducted with blending disabled.
1645
1646         FBOConfig fboConfig0 = FBOConfig(GL_SRGB8_ALPHA8, getTestColorLinear(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_DESTINATION);
1647
1648         const TestRenderPassConfig renderPassConfigs[] =
1649         {
1650                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_ENABLED,  FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_DRAW),
1651                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_DISABLED, FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_DRAW)
1652         };
1653         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1654
1655         this->setTestConfig(renderPassConfigList);
1656 }
1657
1658 bool FboSRGBToggleBlendCase::verifyResult (void)
1659 {
1660         if (tcu::boolAny(tcu::greaterThan(tcu::abs(m_resultsPostDraw[0] - m_resultsPostDraw[1]), getEpsilonError())))
1661                 return true;
1662         else
1663                 return false;
1664 }
1665
1666 class FboSRGBRenderTargetIgnoreCase : public FboSRGBTestCase
1667 {
1668 public:
1669                         FboSRGBRenderTargetIgnoreCase           (Context& context, const char* const name, const char* const description)
1670                                 : FboSRGBTestCase                               (context, name, description) {}
1671                         ~FboSRGBRenderTargetIgnoreCase          (void) {}
1672
1673         void    setupTest                                                       (void);
1674         bool    verifyResult                                            (void);
1675 };
1676
1677 void FboSRGBRenderTargetIgnoreCase::setupTest (void)
1678 {
1679         // TEST INFO:
1680         // Check if render targets that are non-RGB ignore the state of GL_FRAMEBUFFER_SRGB_EXT. Rendering to an fbo with non-sRGB color
1681         // attachment should ignore color space conversion, producing linear color.
1682
1683         FBOConfig fboConfig0 = FBOConfig(GL_RGBA8, getTestColorBlank(), GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_DESTINATION);
1684
1685         const TestRenderPassConfig renderPassConfigs[] =
1686         {
1687                 TestRenderPassConfig(TEXTURESOURCESTYPE_RGBA, fboConfig0, FRAMEBUFFERSRGB_ENABLED,  FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_DRAW)
1688
1689         };
1690         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1691
1692         this->setTestConfig(renderPassConfigList);
1693 }
1694
1695 bool FboSRGBRenderTargetIgnoreCase::verifyResult (void)
1696 {
1697         if (tcu::boolAll(tcu::lessThan(tcu::abs(m_resultsPostDraw[0] - getTestColorLinear()), getEpsilonError())) || tcu::boolAll(tcu::equal(m_resultsPostDraw[0], getTestColorLinear())))
1698                 return true;
1699         else
1700                 return false;
1701 }
1702
1703 class FboSRGBCopyToLinearCase : public FboSRGBTestCase
1704 {
1705 public:
1706                         FboSRGBCopyToLinearCase         (Context& context, const char* const name, const char* const description)
1707                                 : FboSRGBTestCase               (context, name, description) {}
1708                         ~FboSRGBCopyToLinearCase        (void) {}
1709
1710         void    setupTest                                       (void);
1711         bool    verifyResult                            (void);
1712 };
1713
1714 void FboSRGBCopyToLinearCase::setupTest (void)
1715 {
1716         // TEST INFO:
1717         // 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
1718         // an sRGB to linear conversion
1719
1720         FBOConfig fboConfigs[] =
1721         {
1722                 FBOConfig(GL_SRGB8_ALPHA8, getTestColorSRGB(), GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_SOURCE),
1723                 FBOConfig(GL_RGBA8, getTestColorBlank(), GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, FBOTYPE_DESTINATION)
1724         };
1725         std::vector<FBOConfig> fboConfigList(fboConfigs, fboConfigs + DE_LENGTH_OF_ARRAY(fboConfigs));
1726
1727         const TestRenderPassConfig renderPassConfigs[] =
1728         {
1729                 TestRenderPassConfig(TEXTURESOURCESTYPE_NONE, fboConfigList, FRAMEBUFFERSRGB_ENABLED,  FRAMEBUFFERBLEND_DISABLED, TestFunction(false), RENDERERTASK_COPY)
1730         };
1731         std::vector<TestRenderPassConfig> renderPassConfigList(renderPassConfigs, renderPassConfigs + DE_LENGTH_OF_ARRAY(renderPassConfigs));
1732
1733         this->setTestConfig(renderPassConfigList);
1734 }
1735
1736 bool FboSRGBCopyToLinearCase::verifyResult (void)
1737 {
1738         logColor(m_context, "pre-copy source fbo color values", m_resultsPreDraw[0]);
1739         logColor(m_context, "pre-copy destination fbo color values", m_resultsPreDraw[1]);
1740         logColor(m_context, "post-copy source fbo color values", m_resultsPostDraw[0]);
1741         logColor(m_context, "post-copy destination fbo color values", m_resultsPostDraw[1]);
1742
1743         if (tcu::boolAll(tcu::lessThan(tcu::abs(m_resultsPostDraw[1] - getTestColorLinear()), getEpsilonError())) || tcu::boolAll(tcu::equal(m_resultsPostDraw[1], getTestColorLinear())))
1744                 return true;
1745         else
1746                 return false;
1747 }
1748
1749 class FboSRGBUnsupportedEnumCase : public TestCase
1750 {
1751 public:
1752                                         FboSRGBUnsupportedEnumCase      (Context& context, const char* const name, const char* const description);
1753                                         ~FboSRGBUnsupportedEnumCase     (void);
1754
1755         void                    init                                            (void);
1756         void                    deinit                                          (void);
1757         bool                    isInvalidEnum                           (std::string functionName);
1758         IterateResult   iterate                                         (void);
1759 };
1760
1761 FboSRGBUnsupportedEnumCase::FboSRGBUnsupportedEnumCase  (Context& context, const char* const name, const char* const description)
1762         : TestCase                                              (context, name, description)
1763 {
1764 }
1765
1766 FboSRGBUnsupportedEnumCase::~FboSRGBUnsupportedEnumCase (void)
1767 {
1768         FboSRGBUnsupportedEnumCase::deinit();
1769 }
1770
1771 void FboSRGBUnsupportedEnumCase::init (void)
1772 {
1773         // extension requirements for test
1774         if (m_context.getContextInfo().isExtensionSupported("GL_EXT_sRGB_write_control"))
1775                 TCU_THROW(NotSupportedError, "Test requires extension GL_EXT_sRGB_write_control to be unsupported");
1776 }
1777
1778 void FboSRGBUnsupportedEnumCase::deinit (void)
1779 {
1780 }
1781
1782 bool FboSRGBUnsupportedEnumCase::isInvalidEnum (std::string functionName)
1783 {
1784         const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
1785         tcu::TestLog&                   log                     = m_context.getTestContext().getLog();
1786         bool                                    isOk            = true;
1787         glw::GLenum                             error           = GL_NO_ERROR;
1788
1789         log << tcu::TestLog::Message << "Checking call to " << functionName << tcu::TestLog::EndMessage;
1790
1791         error = gl.getError();
1792
1793         if (error != GL_INVALID_ENUM)
1794         {
1795                 log << tcu::TestLog::Message << " returned wrong value [" << glu::getErrorStr(error) << ", expected " << glu::getErrorStr(GL_INVALID_ENUM) << "]" << tcu::TestLog::EndMessage;
1796                 isOk = false;
1797         }
1798
1799         return isOk;
1800 }
1801
1802 FboSRGBUnsupportedEnumCase::IterateResult FboSRGBUnsupportedEnumCase::iterate (void)
1803 {
1804         // TEST INFO:
1805         // API tests that check calls using enum GL_FRAMEBUFFER_SRGB return GL_INVALID_ENUM  when GL_EXT_sRGB_write_control is not supported
1806
1807         const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
1808         bool                                    allPass         = true;
1809         glw::GLboolean                  bEnabled        = GL_FALSE;
1810         glw::GLfloat                    fEnabled        = 0;
1811         glw::GLint                              iEnabled        = 0;
1812         glw::GLint64                    lEnabled        = 0;
1813
1814         m_context.getTestContext().getLog() << tcu::TestLog::Message
1815                                                                                 << "Check calls using enum GL_FRAMEBUFFER_SRGB return GL_INVALID_ENUM  when GL_EXT_sRGB_write_control is not supported\n\n"
1816                                                                                 << tcu::TestLog::EndMessage;
1817
1818         gl.enable(GL_FRAMEBUFFER_SRGB);
1819         allPass &= isInvalidEnum("glEnable()");
1820
1821         gl.disable(GL_FRAMEBUFFER_SRGB);
1822         allPass &= isInvalidEnum("glDisable()");
1823
1824         gl.isEnabled(GL_FRAMEBUFFER_SRGB);
1825         allPass &= isInvalidEnum("glIsEnabled()");
1826
1827         gl.getBooleanv(GL_FRAMEBUFFER_SRGB, &bEnabled);
1828         allPass &= isInvalidEnum("glGetBooleanv()");
1829
1830         gl.getFloatv(GL_FRAMEBUFFER_SRGB, &fEnabled);
1831         allPass &= isInvalidEnum("glGetFloatv()");
1832
1833         gl.getIntegerv(GL_FRAMEBUFFER_SRGB, &iEnabled);
1834         allPass &= isInvalidEnum("glGetIntegerv()");
1835
1836         gl.getInteger64v(GL_FRAMEBUFFER_SRGB, &lEnabled);
1837         allPass &= isInvalidEnum("glGetInteger64v()");
1838
1839         if (allPass)
1840                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1841         else
1842                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
1843
1844         return STOP;
1845 }
1846
1847 } // anonymous
1848
1849 FboSRGBWriteControlTests::FboSRGBWriteControlTests      (Context& context)
1850         : TestCaseGroup                 (context, "srgb_write_control", "Colorbuffer tests")
1851 {
1852 }
1853
1854 FboSRGBWriteControlTests::~FboSRGBWriteControlTests (void)
1855 {
1856 }
1857
1858 void FboSRGBWriteControlTests::init (void)
1859 {
1860         this->addChild(new FboSRGBQueryCase                                     (m_context, "framebuffer_srgb_enabled",                                                 "srgb enable framebuffer"));
1861         this->addChild(new FboSRGBColAttachCase                         (m_context, "framebuffer_srgb_enabled_col_attach",                              "srgb enable color attachment and framebuffer"));
1862         this->addChild(new FboSRGBToggleBlendCase                       (m_context, "framebuffer_srgb_enabled_blend",                                   "toggle framebuffer srgb settings with blend disabled"));
1863         this->addChild(new FboSRGBRenderTargetIgnoreCase        (m_context, "framebuffer_srgb_enabled_render_target_ignore",    "enable framebuffer srgb, non-srgb render target should ignore"));
1864         this->addChild(new FboSRGBCopyToLinearCase                      (m_context, "framebuffer_srgb_enabled_copy_to_linear",                  "no conversion when blittering between framebuffer srgb and linear"));
1865
1866         // negative
1867         this->addChild(new FboSRGBUnsupportedEnumCase           (m_context, "framebuffer_srgb_unsupported_enum",                                "check error codes for query functions when extension is not supported"));
1868 }
1869
1870 }
1871 } // gles31
1872 } // deqp