modules/gles3/functional/es3fFboColorbufferTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.0 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief FBO colorbuffer tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es3fFboColorbufferTests.hpp"
  25 #include "es3fFboTestCase.hpp"
  26 #include "es3fFboTestUtil.hpp"
  27 #include "gluTextureUtil.hpp"
  28 #include "gluContextInfo.hpp"
  29 #include "tcuImageCompare.hpp"
  30 #include "tcuRGBA.hpp"
  31 #include "tcuTestLog.hpp"
  32 #include "tcuTextureUtil.hpp"
  33 #include "sglrContextUtil.hpp"
  34 #include "deRandom.hpp"
  35 #include "deString.h"
  36 #include "glwEnums.hpp"
  37
  38 namespace deqp
  39 {
  40 namespace gles3
  41 {
  42 namespace Functional
  43 {
  44
  45 using std::string;
  46 using tcu::Vec2;
  47 using tcu::Vec3;
  48 using tcu::Vec4;
  49 using tcu::IVec2;
  50 using tcu::IVec3;
  51 using tcu::IVec4;
  52 using tcu::UVec4;
  53 using tcu::TestLog;
  54 using namespace FboTestUtil;
  55
  56 const tcu::RGBA MIN_THRESHOLD(12, 12, 12, 12);
  57
  58 template <int Size>
  59 static tcu::Vector<float, Size> randomVector (de::Random& rnd, const tcu::Vector<float, Size>& minVal = tcu::Vector<float, Size>(0.0f), const tcu::Vector<float, Size>& maxVal = tcu::Vector<float, Size>(1.0f))
  60 {
  61         tcu::Vector<float, Size> res;
  62         for (int ndx = 0; ndx < Size; ndx++)
  63                 res[ndx] = rnd.getFloat(minVal[ndx], maxVal[ndx]);
  64         return res;
  65 }
  66
  67 static tcu::Vec4 generateRandomColor (de::Random& random)
  68 {
  69         tcu::Vec4 retVal;
  70
  71         for (int i = 0; i < 3; ++i)
  72                 retVal[i] = random.getFloat();
  73         retVal[3] = 1.0f;
  74
  75         return retVal;
  76 }
  77
  78 class FboColorbufferCase : public FboTestCase
  79 {
  80 public:
  81         FboColorbufferCase (Context& context, const char* name, const char* desc, const deUint32 format)
  82                 : FboTestCase                   (context, name, desc)
  83                 , m_format                              (format)
  84         {
  85         }
  86
  87         bool compare (const tcu::Surface& reference, const tcu::Surface& result)
  88         {
  89                 const tcu::RGBA threshold (tcu::max(getFormatThreshold(m_format), MIN_THRESHOLD));
  90
  91                 m_testCtx.getLog() << TestLog::Message << "Comparing images, threshold: " << threshold << TestLog::EndMessage;
  92
  93                 return tcu::bilinearCompare(m_testCtx.getLog(), "Result", "Image comparison result", reference.getAccess(), result.getAccess(), threshold, tcu::COMPARE_LOG_RESULT);
  94         }
  95
  96 protected:
  97         const deUint32  m_format;
  98 };
  99
 100 class FboColorClearCase : public FboColorbufferCase
 101 {
 102 public:
 103         FboColorClearCase (Context& context, const char* name, const char* desc, deUint32 format, int width, int height)
 104                 : FboColorbufferCase    (context, name, desc, format)
 105                 , m_width                               (width)
 106                 , m_height                              (height)
 107         {
 108         }
 109
 110 protected:
 111         void preCheck (void)
 112         {
 113                 checkFormatSupport(m_format);
 114         }
 115
 116         void render (tcu::Surface& dst)
 117         {
 118                 tcu::TextureFormat                      fboFormat       = glu::mapGLInternalFormat(m_format);
 119                 tcu::TextureChannelClass        fmtClass        = tcu::getTextureChannelClass(fboFormat.type);
 120                 tcu::TextureFormatInfo          fmtInfo         = tcu::getTextureFormatInfo(fboFormat);
 121                 de::Random                                      rnd                     (17);
 122                 const int                                       numClears       = 16;
 123                 deUint32                                        fbo                     = 0;
 124                 deUint32                                        rbo                     = 0;
 125
 126                 glGenFramebuffers(1, &fbo);
 127                 glGenRenderbuffers(1, &rbo);
 128
 129                 glBindRenderbuffer(GL_RENDERBUFFER, rbo);
 130                 glRenderbufferStorage(GL_RENDERBUFFER, m_format, m_width, m_height);
 131                 checkError();
 132
 133                 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 134                 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
 135                 checkError();
 136                 checkFramebufferStatus(GL_FRAMEBUFFER);
 137
 138                 glViewport(0, 0, m_width, m_height);
 139
 140                 // Initialize to transparent black.
 141                 switch (fmtClass)
 142                 {
 143                         case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 144                         case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 145                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 146                                 glClearBufferfv(GL_COLOR, 0, Vec4(0.0f).getPtr());
 147                                 break;
 148
 149                         case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 150                                 glClearBufferuiv(GL_COLOR, 0, UVec4(0).getPtr());
 151                                 break;
 152
 153                         case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 154                                 glClearBufferiv(GL_COLOR, 0, IVec4(0).getPtr());
 155                                 break;
 156
 157                         default:
 158                                 DE_ASSERT(DE_FALSE);
 159                 }
 160
 161                 // Do random scissored clears.
 162                 glEnable(GL_SCISSOR_TEST);
 163                 for (int ndx = 0; ndx < numClears; ndx++)
 164                 {
 165                         int             x               = rnd.getInt(0, m_width         - 1);
 166                         int             y               = rnd.getInt(0, m_height        - 1);
 167                         int             w               = rnd.getInt(1, m_width         - x);
 168                         int             h               = rnd.getInt(1, m_height        - y);
 169                         Vec4    color   = randomVector<4>(rnd, fmtInfo.valueMin, fmtInfo.valueMax);
 170
 171                         glScissor(x, y, w, h);
 172
 173                         switch (fmtClass)
 174                         {
 175                                 case tcu::TEXTURECHANNELCLASS_FLOATING_POINT:
 176                                 case tcu::TEXTURECHANNELCLASS_SIGNED_FIXED_POINT:
 177                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_FIXED_POINT:
 178                                         glClearBufferfv(GL_COLOR, 0, color.getPtr());
 179                                         break;
 180
 181                                 case tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER:
 182                                         glClearBufferuiv(GL_COLOR, 0, color.cast<deUint32>().getPtr());
 183                                         break;
 184
 185                                 case tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER:
 186                                         glClearBufferiv(GL_COLOR, 0, color.cast<int>().getPtr());
 187                                         break;
 188
 189                                 default:
 190                                         DE_ASSERT(DE_FALSE);
 191                         }
 192                 }
 193
 194                 // Read results from renderbuffer.
 195                 readPixels(dst, 0, 0, m_width, m_height, fboFormat, fmtInfo.lookupScale, fmtInfo.lookupBias);
 196                 checkError();
 197         }
 198
 199 private:
 200         const int                       m_width;
 201         const int                       m_height;
 202 };
 203
 204 class FboColorMultiTex2DCase : public FboColorbufferCase
 205 {
 206 public:
 207         FboColorMultiTex2DCase (Context& context, const char* name, const char* description, deUint32 tex0Fmt, const IVec2& tex0Size, deUint32 tex1Fmt, const IVec2& tex1Size)
 208                 : FboColorbufferCase    (context, name, description, tex0Fmt)
 209                 , m_tex0Fmt                             (tex0Fmt)
 210                 , m_tex1Fmt                             (tex1Fmt)
 211                 , m_tex0Size                    (tex0Size)
 212                 , m_tex1Size                    (tex1Size)
 213         {
 214         }
 215
 216 protected:
 217         void preCheck (void)
 218         {
 219                 checkFormatSupport(m_tex0Fmt);
 220                 checkFormatSupport(m_tex1Fmt);
 221         }
 222
 223         void render (tcu::Surface& dst)
 224         {
 225                 tcu::TextureFormat              texFmt0                 = glu::mapGLInternalFormat(m_tex0Fmt);
 226                 tcu::TextureFormat              texFmt1                 = glu::mapGLInternalFormat(m_tex1Fmt);
 227                 tcu::TextureFormatInfo  fmtInfo0                = tcu::getTextureFormatInfo(texFmt0);
 228                 tcu::TextureFormatInfo  fmtInfo1                = tcu::getTextureFormatInfo(texFmt1);
 229
 230                 Texture2DShader                 texToFbo0Shader (DataTypes() << glu::TYPE_SAMPLER_2D, getFragmentOutputType(texFmt0), fmtInfo0.valueMax-fmtInfo0.valueMin, fmtInfo0.valueMin);
 231                 Texture2DShader                 texToFbo1Shader (DataTypes() << glu::TYPE_SAMPLER_2D, getFragmentOutputType(texFmt1), fmtInfo1.valueMax-fmtInfo1.valueMin, fmtInfo1.valueMin);
 232                 Texture2DShader                 multiTexShader  (DataTypes() << glu::getSampler2DType(texFmt0) << glu::getSampler2DType(texFmt1), glu::TYPE_FLOAT_VEC4);
 233
 234                 deUint32                                texToFbo0ShaderID = getCurrentContext()->createProgram(&texToFbo0Shader);
 235                 deUint32                                texToFbo1ShaderID = getCurrentContext()->createProgram(&texToFbo1Shader);
 236                 deUint32                                multiTexShaderID  = getCurrentContext()->createProgram(&multiTexShader);
 237
 238                 // Setup shaders
 239                 multiTexShader.setTexScaleBias(0, fmtInfo0.lookupScale * 0.5f, fmtInfo0.lookupBias * 0.5f);
 240                 multiTexShader.setTexScaleBias(1, fmtInfo1.lookupScale * 0.5f, fmtInfo1.lookupBias * 0.5f);
 241                 texToFbo0Shader.setUniforms(*getCurrentContext(), texToFbo0ShaderID);
 242                 texToFbo1Shader.setUniforms(*getCurrentContext(), texToFbo1ShaderID);
 243                 multiTexShader.setUniforms (*getCurrentContext(), multiTexShaderID);
 244
 245                 // Framebuffers.
 246                 deUint32                                fbo0, fbo1;
 247                 deUint32                                tex0, tex1;
 248
 249                 for (int ndx = 0; ndx < 2; ndx++)
 250                 {
 251                         glu::TransferFormat             transferFmt             = glu::getTransferFormat(ndx ? texFmt1 : texFmt0);
 252                         deUint32                                format                  = ndx ? m_tex1Fmt : m_tex0Fmt;
 253                         bool                                    isFilterable    = glu::isGLInternalColorFormatFilterable(format);
 254                         const IVec2&                    size                    = ndx ? m_tex1Size : m_tex0Size;
 255                         deUint32&                               fbo                             = ndx ? fbo1 : fbo0;
 256                         deUint32&                               tex                             = ndx ? tex1 : tex0;
 257
 258                         glGenFramebuffers(1, &fbo);
 259                         glGenTextures(1, &tex);
 260
 261                         glBindTexture(GL_TEXTURE_2D, tex);
 262                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 263                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 264                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  isFilterable ? GL_LINEAR : GL_NEAREST);
 265                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  isFilterable ? GL_LINEAR : GL_NEAREST);
 266                         glTexImage2D(GL_TEXTURE_2D, 0, format, size.x(), size.y(), 0, transferFmt.format, transferFmt.dataType, DE_NULL);
 267
 268                         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 269                         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, tex, 0);
 270                         checkError();
 271                         checkFramebufferStatus(GL_FRAMEBUFFER);
 272                 }
 273
 274                 // Render textures to both framebuffers.
 275                 for (int ndx = 0; ndx < 2; ndx++)
 276                 {
 277                         const deUint32          format          = GL_RGBA;
 278                         const deUint32          dataType        = GL_UNSIGNED_BYTE;
 279                         const int                       texW            = 128;
 280                         const int                       texH            = 128;
 281                         deUint32                        tmpTex          = 0;
 282                         deUint32                        fbo                     = ndx ? fbo1 : fbo0;
 283                         const IVec2&            viewport        = ndx ? m_tex1Size : m_tex0Size;
 284                         tcu::TextureLevel       data            (glu::mapGLTransferFormat(format, dataType), texW, texH, 1);
 285
 286                         if (ndx == 0)
 287                                 tcu::fillWithComponentGradients(data.getAccess(), Vec4(0.0f), Vec4(1.0f));
 288                         else
 289                                 tcu::fillWithGrid(data.getAccess(), 8, Vec4(0.2f, 0.7f, 0.1f, 1.0f), Vec4(0.7f, 0.1f, 0.5f, 0.8f));
 290
 291                         glGenTextures(1, &tmpTex);
 292                         glBindTexture(GL_TEXTURE_2D, tmpTex);
 293                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 294                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 295                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  GL_LINEAR);
 296                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  GL_LINEAR);
 297                         glTexImage2D(GL_TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());
 298
 299                         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 300                         glViewport(0, 0, viewport.x(), viewport.y());
 301                         sglr::drawQuad(*getCurrentContext(), ndx ? texToFbo1ShaderID : texToFbo0ShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 302                 }
 303
 304                 // Render to framebuffer.
 305                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 306                 glViewport(0, 0, getWidth(), getHeight());
 307                 glActiveTexture(GL_TEXTURE0);
 308                 glBindTexture(GL_TEXTURE_2D, tex0);
 309                 glActiveTexture(GL_TEXTURE1);
 310                 glBindTexture(GL_TEXTURE_2D, tex1);
 311                 sglr::drawQuad(*getCurrentContext(), multiTexShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 312
 313                 readPixels(dst, 0, 0, getWidth(), getHeight());
 314         }
 315
 316 private:
 317         deUint32                m_tex0Fmt;
 318         deUint32                m_tex1Fmt;
 319         IVec2                   m_tex0Size;
 320         IVec2                   m_tex1Size;
 321 };
 322
 323 class FboColorTexCubeCase : public FboColorbufferCase
 324 {
 325 public:
 326         FboColorTexCubeCase                     (Context& context, const char* name, const char* description, deUint32 texFmt, const IVec2& texSize)
 327                 : FboColorbufferCase    (context, name, description, texFmt)
 328                 , m_texSize                             (texSize)
 329         {
 330         }
 331
 332 protected:
 333         void preCheck (void)
 334         {
 335                 checkFormatSupport(m_format);
 336         }
 337
 338         void render (tcu::Surface& dst)
 339         {
 340                 static const deUint32 cubeGLFaces[] =
 341                 {
 342                         GL_TEXTURE_CUBE_MAP_POSITIVE_X,
 343                         GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
 344                         GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
 345                         GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
 346                         GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
 347                         GL_TEXTURE_CUBE_MAP_NEGATIVE_Z
 348                 };
 349
 350                 static const tcu::CubeFace cubeTexFaces[] =
 351                 {
 352                         tcu::CUBEFACE_POSITIVE_X,
 353                         tcu::CUBEFACE_POSITIVE_Y,
 354                         tcu::CUBEFACE_POSITIVE_Z,
 355                         tcu::CUBEFACE_NEGATIVE_X,
 356                         tcu::CUBEFACE_NEGATIVE_Y,
 357                         tcu::CUBEFACE_NEGATIVE_Z
 358                 };
 359
 360                 de::Random                              rnd                                     (deStringHash(getName()) ^ 0x9eef603d);
 361                 tcu::TextureFormat              texFmt                          = glu::mapGLInternalFormat(m_format);
 362                 tcu::TextureFormatInfo  fmtInfo                         = tcu::getTextureFormatInfo(texFmt);
 363
 364                 Texture2DShader                 texToFboShader          (DataTypes() << glu::TYPE_SAMPLER_2D, getFragmentOutputType(texFmt), fmtInfo.valueMax-fmtInfo.valueMin, fmtInfo.valueMin);
 365                 TextureCubeShader               cubeTexShader           (glu::getSamplerCubeType(texFmt), glu::TYPE_FLOAT_VEC4);
 366
 367                 deUint32                                texToFboShaderID        = getCurrentContext()->createProgram(&texToFboShader);
 368                 deUint32                                cubeTexShaderID         = getCurrentContext()->createProgram(&cubeTexShader);
 369
 370                 // Setup shaders
 371                 texToFboShader.setUniforms(*getCurrentContext(), texToFboShaderID);
 372                 cubeTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias);
 373
 374                 // Framebuffers.
 375                 std::vector<deUint32>   fbos;
 376                 deUint32                                tex;
 377
 378                 {
 379                         glu::TransferFormat             transferFmt             = glu::getTransferFormat(texFmt);
 380                         bool                                    isFilterable    = glu::isGLInternalColorFormatFilterable(m_format);
 381                         const IVec2&                    size                    = m_texSize;
 382
 383
 384                         glGenTextures(1, &tex);
 385
 386                         glBindTexture(GL_TEXTURE_CUBE_MAP,              tex);
 387                         glTexParameteri(GL_TEXTURE_CUBE_MAP,    GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 388                         glTexParameteri(GL_TEXTURE_CUBE_MAP,    GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 389                         glTexParameteri(GL_TEXTURE_CUBE_MAP,    GL_TEXTURE_MIN_FILTER,  isFilterable ? GL_LINEAR : GL_NEAREST);
 390                         glTexParameteri(GL_TEXTURE_CUBE_MAP,    GL_TEXTURE_MAG_FILTER,  isFilterable ? GL_LINEAR : GL_NEAREST);
 391
 392                         // Generate an image and FBO for each cube face
 393                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cubeGLFaces); ndx++)
 394                                 glTexImage2D(cubeGLFaces[ndx], 0, m_format, size.x(), size.y(), 0, transferFmt.format, transferFmt.dataType, DE_NULL);
 395                         checkError();
 396
 397                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cubeGLFaces); ndx++)
 398                         {
 399                                 deUint32                        layerFbo;
 400
 401                                 glGenFramebuffers(1, &layerFbo);
 402                                 glBindFramebuffer(GL_FRAMEBUFFER, layerFbo);
 403                                 glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, cubeGLFaces[ndx], tex, 0);
 404                                 checkError();
 405                                 checkFramebufferStatus(GL_FRAMEBUFFER);
 406
 407                                 fbos.push_back(layerFbo);
 408                         }
 409                 }
 410
 411                 // Render test images to random cube faces
 412                 std::vector<int> order;
 413
 414                 for (size_t n = 0; n < fbos.size(); n++)
 415                         order.push_back((int)n);
 416                 rnd.shuffle(order.begin(), order.end());
 417
 418                 DE_ASSERT(order.size() >= 4);
 419                 for (int ndx = 0; ndx < 4; ndx++)
 420                 {
 421                         const int                       face            = order[ndx];
 422                         const deUint32          format          = GL_RGBA;
 423                         const deUint32          dataType        = GL_UNSIGNED_BYTE;
 424                         const int                       texW            = 128;
 425                         const int                       texH            = 128;
 426                         deUint32                        tmpTex          = 0;
 427                         const deUint32          fbo                     = fbos[face];
 428                         const IVec2&            viewport        = m_texSize;
 429                         tcu::TextureLevel       data            (glu::mapGLTransferFormat(format, dataType), texW, texH, 1);
 430
 431                         tcu::fillWithGrid(data.getAccess(), 8, generateRandomColor(rnd), Vec4(0.0f));
 432
 433                         glGenTextures(1, &tmpTex);
 434                         glBindTexture(GL_TEXTURE_2D, tmpTex);
 435                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 436                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 437                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  GL_LINEAR);
 438                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  GL_LINEAR);
 439                         glTexImage2D(GL_TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());
 440
 441                         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 442                         glViewport(0, 0, viewport.x(), viewport.y());
 443                         sglr::drawQuad(*getCurrentContext(), texToFboShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 444                         checkError();
 445
 446                         // Render to framebuffer
 447                         {
 448                                 const Vec3              p0      = Vec3(float(ndx % 2) - 1.0f, float(ndx / 2) - 1.0f, 0.0f);
 449                                 const Vec3              p1      = p0 + Vec3(1.0f, 1.0f, 0.0f);
 450
 451                                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 452                                 glViewport(0, 0, getWidth(), getHeight());
 453
 454                                 glActiveTexture(GL_TEXTURE0);
 455                                 glBindTexture(GL_TEXTURE_CUBE_MAP, tex);
 456
 457                                 cubeTexShader.setFace(cubeTexFaces[face]);
 458                                 cubeTexShader.setUniforms(*getCurrentContext(), cubeTexShaderID);
 459
 460                                 sglr::drawQuad(*getCurrentContext(), cubeTexShaderID, p0, p1);
 461                                 checkError();
 462                         }
 463                 }
 464
 465                 readPixels(dst, 0, 0, getWidth(), getHeight());
 466         }
 467
 468 private:
 469         IVec2                   m_texSize;
 470 };
 471
 472 class FboColorTex2DArrayCase : public FboColorbufferCase
 473 {
 474 public:
 475         FboColorTex2DArrayCase (Context& context, const char* name, const char* description, deUint32 texFmt, const IVec3& texSize)
 476                 : FboColorbufferCase    (context, name, description, texFmt)
 477                 , m_texSize                             (texSize)
 478         {
 479         }
 480
 481 protected:
 482         void preCheck (void)
 483         {
 484                 checkFormatSupport(m_format);
 485         }
 486
 487         void render (tcu::Surface& dst)
 488         {
 489                 de::Random                              rnd                                     (deStringHash(getName()) ^ 0xed607a89);
 490                 tcu::TextureFormat              texFmt                          = glu::mapGLInternalFormat(m_format);
 491                 tcu::TextureFormatInfo  fmtInfo                         = tcu::getTextureFormatInfo(texFmt);
 492
 493                 Texture2DShader                 texToFboShader          (DataTypes() << glu::TYPE_SAMPLER_2D, getFragmentOutputType(texFmt), fmtInfo.valueMax-fmtInfo.valueMin, fmtInfo.valueMin);
 494                 Texture2DArrayShader    arrayTexShader          (glu::getSampler2DArrayType(texFmt), glu::TYPE_FLOAT_VEC4);
 495
 496                 deUint32                                texToFboShaderID        = getCurrentContext()->createProgram(&texToFboShader);
 497                 deUint32                                arrayTexShaderID        = getCurrentContext()->createProgram(&arrayTexShader);
 498
 499                 // Setup textures
 500                 texToFboShader.setUniforms(*getCurrentContext(), texToFboShaderID);
 501                 arrayTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias);
 502
 503                 // Framebuffers.
 504                 std::vector<deUint32>   fbos;
 505                 deUint32                                tex;
 506
 507                 {
 508                         glu::TransferFormat             transferFmt             = glu::getTransferFormat(texFmt);
 509                         bool                                    isFilterable    = glu::isGLInternalColorFormatFilterable(m_format);
 510                         const IVec3&                    size                    = m_texSize;
 511
 512
 513                         glGenTextures(1, &tex);
 514
 515                         glBindTexture(GL_TEXTURE_2D_ARRAY,              tex);
 516                         glTexParameteri(GL_TEXTURE_2D_ARRAY,    GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 517                         glTexParameteri(GL_TEXTURE_2D_ARRAY,    GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 518                         glTexParameteri(GL_TEXTURE_2D_ARRAY,    GL_TEXTURE_WRAP_R,              GL_CLAMP_TO_EDGE);
 519                         glTexParameteri(GL_TEXTURE_2D_ARRAY,    GL_TEXTURE_MIN_FILTER,  isFilterable ? GL_LINEAR : GL_NEAREST);
 520                         glTexParameteri(GL_TEXTURE_2D_ARRAY,    GL_TEXTURE_MAG_FILTER,  isFilterable ? GL_LINEAR : GL_NEAREST);
 521                         glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, m_format, size.x(), size.y(), size.z(), 0, transferFmt.format, transferFmt.dataType, DE_NULL);
 522
 523                         // Generate an FBO for each layer
 524                         for (int ndx = 0; ndx < m_texSize.z(); ndx++)
 525                         {
 526                                 deUint32                        layerFbo;
 527
 528                                 glGenFramebuffers(1, &layerFbo);
 529                                 glBindFramebuffer(GL_FRAMEBUFFER, layerFbo);
 530                                 glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, 0, ndx);
 531                                 checkError();
 532                                 checkFramebufferStatus(GL_FRAMEBUFFER);
 533
 534                                 fbos.push_back(layerFbo);
 535                         }
 536                 }
 537
 538                 // Render test images to random texture layers
 539                 std::vector<int>                order;
 540
 541                 for (size_t n = 0; n < fbos.size(); n++)
 542                         order.push_back((int)n);
 543                 rnd.shuffle(order.begin(), order.end());
 544
 545                 for (size_t ndx = 0; ndx < order.size(); ndx++)
 546                 {
 547                         const int                       layer           = order[ndx];
 548                         const deUint32          format          = GL_RGBA;
 549                         const deUint32          dataType        = GL_UNSIGNED_BYTE;
 550                         const int                       texW            = 128;
 551                         const int                       texH            = 128;
 552                         deUint32                        tmpTex          = 0;
 553                         const deUint32          fbo                     = fbos[layer];
 554                         const IVec3&            viewport        = m_texSize;
 555                         tcu::TextureLevel       data            (glu::mapGLTransferFormat(format, dataType), texW, texH, 1);
 556
 557                         tcu::fillWithGrid(data.getAccess(), 8, generateRandomColor(rnd), Vec4(0.0f));
 558
 559                         glGenTextures(1, &tmpTex);
 560                         glBindTexture(GL_TEXTURE_2D, tmpTex);
 561                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 562                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 563                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  GL_LINEAR);
 564                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  GL_LINEAR);
 565                         glTexImage2D(GL_TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());
 566
 567                         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 568                         glViewport(0, 0, viewport.x(), viewport.y());
 569                         sglr::drawQuad(*getCurrentContext(), texToFboShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 570                         checkError();
 571
 572                         // Render to framebuffer
 573                         {
 574                                 const Vec3              p0      = Vec3(float(ndx % 2) - 1.0f, float(ndx / 2) - 1.0f, 0.0f);
 575                                 const Vec3              p1      = p0 + Vec3(1.0f, 1.0f, 0.0f);
 576
 577                                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 578                                 glViewport(0, 0, getWidth(), getHeight());
 579
 580                                 glActiveTexture(GL_TEXTURE0);
 581                                 glBindTexture(GL_TEXTURE_2D_ARRAY, tex);
 582
 583                                 arrayTexShader.setLayer(layer);
 584                                 arrayTexShader.setUniforms(*getCurrentContext(), arrayTexShaderID);
 585
 586                                 sglr::drawQuad(*getCurrentContext(), arrayTexShaderID, p0, p1);
 587                                 checkError();
 588                         }
 589                 }
 590
 591                 readPixels(dst, 0, 0, getWidth(), getHeight());
 592         }
 593
 594 private:
 595         IVec3                   m_texSize;
 596 };
 597
 598 class FboColorTex3DCase : public FboColorbufferCase
 599 {
 600 public:
 601         FboColorTex3DCase (Context& context, const char* name, const char* description, deUint32 texFmt, const IVec3& texSize)
 602                 : FboColorbufferCase    (context, name, description, texFmt)
 603                 , m_texSize                             (texSize)
 604         {
 605         }
 606
 607 protected:
 608         void preCheck (void)
 609         {
 610                 checkFormatSupport(m_format);
 611         }
 612
 613         void render (tcu::Surface& dst)
 614         {
 615                 de::Random                              rnd                             (deStringHash(getName()) ^ 0x74d947b2);
 616                 tcu::TextureFormat              texFmt                  = glu::mapGLInternalFormat(m_format);
 617                 tcu::TextureFormatInfo  fmtInfo                 = tcu::getTextureFormatInfo(texFmt);
 618
 619                 Texture2DShader                 texToFboShader  (DataTypes() << glu::TYPE_SAMPLER_2D, getFragmentOutputType(texFmt), fmtInfo.valueMax-fmtInfo.valueMin, fmtInfo.valueMin);
 620                 Texture3DShader                 tdTexShader             (glu::getSampler3DType(texFmt), glu::TYPE_FLOAT_VEC4);
 621
 622                 deUint32                                texToFboShaderID= getCurrentContext()->createProgram(&texToFboShader);
 623                 deUint32                                tdTexShaderID   = getCurrentContext()->createProgram(&tdTexShader);
 624
 625                 // Setup shaders
 626                 texToFboShader.setUniforms(*getCurrentContext(), texToFboShaderID);
 627                 tdTexShader.setTexScaleBias(fmtInfo.lookupScale, fmtInfo.lookupBias);
 628
 629                 // Framebuffers.
 630                 std::vector<deUint32>   fbos;
 631                 deUint32                                tex;
 632
 633                 {
 634                         glu::TransferFormat             transferFmt             = glu::getTransferFormat(texFmt);
 635                         const IVec3&                    size                    = m_texSize;
 636
 637                         glGenTextures(1, &tex);
 638
 639                         glBindTexture(GL_TEXTURE_3D,            tex);
 640                         glTexParameteri(GL_TEXTURE_3D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 641                         glTexParameteri(GL_TEXTURE_3D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 642                         glTexParameteri(GL_TEXTURE_3D,  GL_TEXTURE_WRAP_R,              GL_CLAMP_TO_EDGE);
 643                         glTexParameteri(GL_TEXTURE_3D,  GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
 644                         glTexParameteri(GL_TEXTURE_3D,  GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
 645                         glTexImage3D(GL_TEXTURE_3D, 0, m_format, size.x(), size.y(), size.z(), 0, transferFmt.format, transferFmt.dataType, DE_NULL);
 646
 647                         // Generate an FBO for each layer
 648                         for (int ndx = 0; ndx < m_texSize.z(); ndx++)
 649                         {
 650                                 deUint32                        layerFbo;
 651
 652                                 glGenFramebuffers(1, &layerFbo);
 653                                 glBindFramebuffer(GL_FRAMEBUFFER, layerFbo);
 654                                 glFramebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, tex, 0, ndx);
 655                                 checkError();
 656                                 checkFramebufferStatus(GL_FRAMEBUFFER);
 657
 658                                 fbos.push_back(layerFbo);
 659                         }
 660                 }
 661
 662                 // Render test images to random texture layers
 663                 std::vector<int> order;
 664
 665                 for (size_t n = 0; n < fbos.size(); n++)
 666                         order.push_back((int)n);
 667                 rnd.shuffle(order.begin(), order.end());
 668
 669                 for (size_t ndx = 0; ndx < order.size(); ndx++)
 670                 {
 671                         const int                       layer           = order[ndx];
 672                         const deUint32          format          = GL_RGBA;
 673                         const deUint32          dataType        = GL_UNSIGNED_BYTE;
 674                         const int                       texW            = 128;
 675                         const int                       texH            = 128;
 676                         deUint32                        tmpTex          = 0;
 677                         const deUint32          fbo                     = fbos[layer];
 678                         const IVec3&            viewport        = m_texSize;
 679                         tcu::TextureLevel       data            (glu::mapGLTransferFormat(format, dataType), texW, texH, 1);
 680
 681                         tcu::fillWithGrid(data.getAccess(), 8, generateRandomColor(rnd), Vec4(0.0f));
 682
 683                         glGenTextures(1, &tmpTex);
 684                         glBindTexture(GL_TEXTURE_2D, tmpTex);
 685                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 686                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 687                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  GL_LINEAR);
 688                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  GL_LINEAR);
 689                         glTexImage2D(GL_TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());
 690
 691                         glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 692                         glViewport(0, 0, viewport.x(), viewport.y());
 693                         sglr::drawQuad(*getCurrentContext() , texToFboShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 694                         checkError();
 695
 696                         // Render to framebuffer
 697                         {
 698                                 const Vec3              p0      = Vec3(float(ndx % 2) - 1.0f, float(ndx / 2) - 1.0f, 0.0f);
 699                                 const Vec3              p1      = p0 + Vec3(1.0f, 1.0f, 0.0f);
 700
 701                                 glBindFramebuffer(GL_FRAMEBUFFER, 0);
 702                                 glViewport(0, 0, getWidth(), getHeight());
 703
 704                                 glActiveTexture(GL_TEXTURE0);
 705                                 glBindTexture(GL_TEXTURE_3D, tex);
 706
 707                                 tdTexShader.setDepth(float(layer) / float(m_texSize.z()-1));
 708                                 tdTexShader.setUniforms(*getCurrentContext(), tdTexShaderID);
 709
 710                                 sglr::drawQuad(*getCurrentContext(), tdTexShaderID, p0, p1);
 711                                 checkError();
 712                         }
 713                 }
 714
 715                 readPixels(dst, 0, 0, getWidth(), getHeight());
 716         }
 717
 718 private:
 719         IVec3                   m_texSize;
 720 };
 721
 722 class FboBlendCase : public FboColorbufferCase
 723 {
 724 public:
 725         FboBlendCase (Context& context, const char* name, const char* desc, deUint32 format, IVec2 size, deUint32 funcRGB, deUint32 funcAlpha, deUint32 srcRGB, deUint32 dstRGB, deUint32 srcAlpha, deUint32 dstAlpha)
 726                 : FboColorbufferCase    (context, name, desc, format)
 727                 , m_size                                (size)
 728                 , m_funcRGB                             (funcRGB)
 729                 , m_funcAlpha                   (funcAlpha)
 730                 , m_srcRGB                              (srcRGB)
 731                 , m_dstRGB                              (dstRGB)
 732                 , m_srcAlpha                    (srcAlpha)
 733                 , m_dstAlpha                    (dstAlpha)
 734         {
 735         }
 736
 737 protected:
 738         void preCheck (void)
 739         {
 740                 checkFormatSupport(m_format);
 741         }
 742
 743         void render (tcu::Surface& dst)
 744         {
 745                 // \note Assumes floating-point or fixed-point format.
 746                 tcu::TextureFormat                      fboFmt                  = glu::mapGLInternalFormat(m_format);
 747                 Texture2DShader                         texShader               (DataTypes() << glu::TYPE_SAMPLER_2D, glu::TYPE_FLOAT_VEC4);
 748                 GradientShader                          gradShader              (glu::TYPE_FLOAT_VEC4);
 749                 deUint32                                        texShaderID             = getCurrentContext()->createProgram(&texShader);
 750                 deUint32                                        gradShaderID    = getCurrentContext()->createProgram(&gradShader);
 751                 deUint32                                        fbo                             = 0;
 752                 deUint32                                        rbo                             = 0;
 753
 754                 // Setup shaders
 755                 texShader.setUniforms (*getCurrentContext(), texShaderID);
 756                 gradShader.setGradient(*getCurrentContext(), gradShaderID, tcu::Vec4(0.0f), tcu::Vec4(1.0f));
 757
 758                 glGenFramebuffers(1, &fbo);
 759                 glGenRenderbuffers(1, &rbo);
 760
 761                 glBindRenderbuffer(GL_RENDERBUFFER, rbo);
 762                 glRenderbufferStorage(GL_RENDERBUFFER, m_format, m_size.x(), m_size.y());
 763                 checkError();
 764
 765                 glBindFramebuffer(GL_FRAMEBUFFER, fbo);
 766                 glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo);
 767                 checkError();
 768                 checkFramebufferStatus(GL_FRAMEBUFFER);
 769
 770                 glViewport(0, 0, m_size.x(), m_size.y());
 771
 772                 // Fill framebuffer with grid pattern.
 773                 {
 774                         const deUint32          format          = GL_RGBA;
 775                         const deUint32          dataType        = GL_UNSIGNED_BYTE;
 776                         const int                       texW            = 128;
 777                         const int                       texH            = 128;
 778                         deUint32                        gridTex         = 0;
 779                         tcu::TextureLevel       data            (glu::mapGLTransferFormat(format, dataType), texW, texH, 1);
 780
 781                         tcu::fillWithGrid(data.getAccess(), 8, Vec4(0.2f, 0.7f, 0.1f, 1.0f), Vec4(0.7f, 0.1f, 0.5f, 0.8f));
 782
 783                         glGenTextures(1, &gridTex);
 784                         glBindTexture(GL_TEXTURE_2D, gridTex);
 785                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 786                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 787                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  GL_LINEAR);
 788                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  GL_LINEAR);
 789                         glTexImage2D(GL_TEXTURE_2D, 0, format, texW, texH, 0, format, dataType, data.getAccess().getDataPtr());
 790
 791                         sglr::drawQuad(*getCurrentContext(), texShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 792                 }
 793
 794                 // Setup blend.
 795                 glEnable(GL_BLEND);
 796                 glBlendEquationSeparate(m_funcRGB, m_funcAlpha);
 797                 glBlendFuncSeparate(m_srcRGB, m_dstRGB, m_srcAlpha, m_dstAlpha);
 798
 799                 // Render gradient with blend.
 800                 sglr::drawQuad(*getCurrentContext(), gradShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 801
 802                 readPixels(dst, 0, 0, m_size.x(), m_size.y(), fboFmt, Vec4(1.0f), Vec4(0.0f));
 803         }
 804
 805 private:
 806         IVec2           m_size;
 807         deUint32        m_funcRGB;
 808         deUint32        m_funcAlpha;
 809         deUint32        m_srcRGB;
 810         deUint32        m_dstRGB;
 811         deUint32        m_srcAlpha;
 812         deUint32        m_dstAlpha;
 813 };
 814
 815 class FboRepeatedClearSampleTex2DCase : public FboColorbufferCase
 816 {
 817 public:
 818         FboRepeatedClearSampleTex2DCase (Context& context, const char* name, const char* desc, deUint32 format)
 819                 : FboColorbufferCase(context, name, desc, format)
 820         {
 821         }
 822
 823 protected:
 824         void preCheck (void)
 825         {
 826                 checkFormatSupport(m_format);
 827         }
 828
 829         void render (tcu::Surface& dst)
 830         {
 831                 const tcu::TextureFormat                fboFormat               = glu::mapGLInternalFormat(m_format);
 832                 const tcu::TextureFormatInfo    fmtInfo                 = tcu::getTextureFormatInfo(fboFormat);
 833                 const int                                               numRowsCols             = 4;
 834                 const int                                               cellSize                = 16;
 835                 const int                                               fboSizes[]              = { cellSize, cellSize*numRowsCols };
 836
 837                 Texture2DShader                                 fboBlitShader   (DataTypes() << glu::getSampler2DType(fboFormat), getFragmentOutputType(fboFormat), Vec4(1.0f), Vec4(0.0f));
 838                 const deUint32                                  fboBlitShaderID = getCurrentContext()->createProgram(&fboBlitShader);
 839
 840                 de::Random                                              rnd                             (18169662);
 841                 deUint32                                                fbos[]                  = { 0, 0 };
 842                 deUint32                                                textures[]              = { 0, 0 };
 843
 844                 glGenFramebuffers(2, &fbos[0]);
 845                 glGenTextures(2, &textures[0]);
 846
 847                 for (int fboNdx = 0; fboNdx < DE_LENGTH_OF_ARRAY(fbos); fboNdx++)
 848                 {
 849                         glBindTexture(GL_TEXTURE_2D, textures[fboNdx]);
 850                         glTexStorage2D(GL_TEXTURE_2D, 1, m_format, fboSizes[fboNdx], fboSizes[fboNdx]);
 851                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 852                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 853                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
 854                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
 855                         checkError();
 856
 857                         glBindFramebuffer(GL_FRAMEBUFFER, fbos[fboNdx]);
 858                         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textures[fboNdx], 0);
 859                         checkError();
 860                         checkFramebufferStatus(GL_FRAMEBUFFER);
 861                 }
 862
 863                 // larger fbo bound -- clear to transparent black
 864                 clearColorBuffer(fboFormat, Vec4(0.0f));
 865
 866                 fboBlitShader.setUniforms(*getCurrentContext(), fboBlitShaderID);
 867                 glBindTexture(GL_TEXTURE_2D, textures[0]);
 868
 869                 for (int cellY = 0; cellY < numRowsCols; cellY++)
 870                 for (int cellX = 0; cellX < numRowsCols; cellX++)
 871                 {
 872                         const Vec4      color   = randomVector<4>(rnd, fmtInfo.valueMin, fmtInfo.valueMax);
 873
 874                         glBindFramebuffer(GL_FRAMEBUFFER, fbos[0]);
 875                         clearColorBuffer(fboFormat, color);
 876
 877                         glBindFramebuffer(GL_FRAMEBUFFER, fbos[1]);
 878                         glViewport(cellX*cellSize, cellY*cellSize, cellSize, cellSize);
 879                         sglr::drawQuad(*getCurrentContext(), fboBlitShaderID, Vec3(-1.0f, -1.0f, 0.0f), Vec3(1.0f, 1.0f, 0.0f));
 880                 }
 881
 882                 readPixels(dst, 0, 0, fboSizes[1], fboSizes[1], fboFormat, fmtInfo.lookupScale, fmtInfo.lookupBias);
 883                 checkError();
 884         }
 885 };
 886
 887 class FboRepeatedClearBlitTex2DCase : public FboColorbufferCase
 888 {
 889 public:
 890         FboRepeatedClearBlitTex2DCase (Context& context, const char* name, const char* desc, deUint32 format)
 891                 : FboColorbufferCase(context, name, desc, format)
 892         {
 893         }
 894
 895 protected:
 896         void preCheck (void)
 897         {
 898                 checkFormatSupport(m_format);
 899         }
 900
 901         void render (tcu::Surface& dst)
 902         {
 903                 const tcu::TextureFormat                fboFormat               = glu::mapGLInternalFormat(m_format);
 904                 const tcu::TextureFormatInfo    fmtInfo                 = tcu::getTextureFormatInfo(fboFormat);
 905                 const int                                               numRowsCols             = 4;
 906                 const int                                               cellSize                = 16;
 907                 const int                                               fboSizes[]              = { cellSize, cellSize*numRowsCols };
 908
 909                 de::Random                                              rnd                             (18169662);
 910                 deUint32                                                fbos[]                  = { 0, 0 };
 911                 deUint32                                                textures[]              = { 0, 0 };
 912
 913                 glGenFramebuffers(2, &fbos[0]);
 914                 glGenTextures(2, &textures[0]);
 915
 916                 for (int fboNdx = 0; fboNdx < DE_LENGTH_OF_ARRAY(fbos); fboNdx++)
 917                 {
 918                         glBindTexture(GL_TEXTURE_2D, textures[fboNdx]);
 919                         glTexStorage2D(GL_TEXTURE_2D, 1, m_format, fboSizes[fboNdx], fboSizes[fboNdx]);
 920                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_S,              GL_CLAMP_TO_EDGE);
 921                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_WRAP_T,              GL_CLAMP_TO_EDGE);
 922                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MIN_FILTER,  GL_NEAREST);
 923                         glTexParameteri(GL_TEXTURE_2D,  GL_TEXTURE_MAG_FILTER,  GL_NEAREST);
 924                         checkError();
 925
 926                         glBindFramebuffer(GL_FRAMEBUFFER, fbos[fboNdx]);
 927                         glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, textures[fboNdx], 0);
 928                         checkError();
 929                         checkFramebufferStatus(GL_FRAMEBUFFER);
 930                 }
 931
 932                 // larger fbo bound -- clear to transparent black
 933                 clearColorBuffer(fboFormat, Vec4(0.0f));
 934
 935                 for (int cellY = 0; cellY < numRowsCols; cellY++)
 936                 for (int cellX = 0; cellX < numRowsCols; cellX++)
 937                 {
 938                         const Vec4      color   = randomVector<4>(rnd, fmtInfo.valueMin, fmtInfo.valueMax);
 939
 940                         glBindFramebuffer(GL_FRAMEBUFFER, fbos[0]);
 941                         clearColorBuffer(fboFormat, color);
 942
 943                         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbos[1]);
 944                         glBlitFramebuffer(0, 0, cellSize, cellSize, cellX*cellSize, cellY*cellSize, (cellX+1)*cellSize, (cellY+1)*cellSize, GL_COLOR_BUFFER_BIT, GL_NEAREST);
 945                 }
 946
 947                 glBindFramebuffer(GL_FRAMEBUFFER, fbos[1]);
 948                 readPixels(dst, 0, 0, fboSizes[1], fboSizes[1], fboFormat, fmtInfo.lookupScale, fmtInfo.lookupBias);
 949                 checkError();
 950         }
 951 };
 952
 953 class FboRepeatedClearBlitRboCase : public FboColorbufferCase
 954 {
 955 public:
 956         FboRepeatedClearBlitRboCase (Context& context, const char* name, const char* desc, deUint32 format)
 957                 : FboColorbufferCase(context, name, desc, format)
 958         {
 959         }
 960
 961 protected:
 962         void preCheck (void)
 963         {
 964                 checkFormatSupport(m_format);
 965         }
 966
 967         void render (tcu::Surface& dst)
 968         {
 969                 const tcu::TextureFormat                fboFormat               = glu::mapGLInternalFormat(m_format);
 970                 const tcu::TextureFormatInfo    fmtInfo                 = tcu::getTextureFormatInfo(fboFormat);
 971                 const int                                               numRowsCols             = 4;
 972                 const int                                               cellSize                = 16;
 973                 const int                                               fboSizes[]              = { cellSize, cellSize*numRowsCols };
 974
 975                 de::Random                                              rnd                             (18169662);
 976                 deUint32                                                fbos[]                  = { 0, 0 };
 977                 deUint32                                                rbos[]                  = { 0, 0 };
 978
 979                 glGenFramebuffers(2, &fbos[0]);
 980                 glGenRenderbuffers(2, &rbos[0]);
 981
 982                 for (int fboNdx = 0; fboNdx < DE_LENGTH_OF_ARRAY(fbos); fboNdx++)
 983                 {
 984                         glBindRenderbuffer(GL_RENDERBUFFER, rbos[fboNdx]);
 985                         glRenderbufferStorage(GL_RENDERBUFFER, m_format, fboSizes[fboNdx], fboSizes[fboNdx]);
 986                         checkError();
 987
 988                         glBindFramebuffer(GL_FRAMEBUFFER, fbos[fboNdx]);
 989                         glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbos[fboNdx]);
 990                         checkError();
 991                         checkFramebufferStatus(GL_FRAMEBUFFER);
 992                 }
 993
 994                 // larger fbo bound -- clear to transparent black
 995                 clearColorBuffer(fboFormat, Vec4(0.0f));
 996
 997                 for (int cellY = 0; cellY < numRowsCols; cellY++)
 998                 for (int cellX = 0; cellX < numRowsCols; cellX++)
 999                 {
1000                         const Vec4      color   = randomVector<4>(rnd, fmtInfo.valueMin, fmtInfo.valueMax);
1001
1002                         glBindFramebuffer(GL_FRAMEBUFFER, fbos[0]);
1003                         clearColorBuffer(fboFormat, color);
1004
1005                         glBindFramebuffer(GL_DRAW_FRAMEBUFFER, fbos[1]);
1006                         glBlitFramebuffer(0, 0, cellSize, cellSize, cellX*cellSize, cellY*cellSize, (cellX+1)*cellSize, (cellY+1)*cellSize, GL_COLOR_BUFFER_BIT, GL_NEAREST);
1007                 }
1008
1009                 glBindFramebuffer(GL_FRAMEBUFFER, fbos[1]);
1010                 readPixels(dst, 0, 0, fboSizes[1], fboSizes[1], fboFormat, fmtInfo.lookupScale, fmtInfo.lookupBias);
1011                 checkError();
1012         }
1013 };
1014
1015 FboColorTests::FboColorTests (Context& context)
1016         : TestCaseGroup(context, "color", "Colorbuffer tests")
1017 {
1018 }
1019
1020 FboColorTests::~FboColorTests (void)
1021 {
1022 }
1023
1024 void FboColorTests::init (void)
1025 {
1026         static const deUint32 colorFormats[] =
1027         {
1028                 // RGBA formats
1029                 GL_RGBA32I,
1030                 GL_RGBA32UI,
1031                 GL_RGBA16I,
1032                 GL_RGBA16UI,
1033                 GL_RGBA8,
1034                 GL_RGBA8I,
1035                 GL_RGBA8UI,
1036                 GL_SRGB8_ALPHA8,
1037                 GL_RGB10_A2,
1038                 GL_RGB10_A2UI,
1039                 GL_RGBA4,
1040                 GL_RGB5_A1,
1041
1042                 // RGB formats
1043                 GL_RGB8,
1044                 GL_RGB565,
1045
1046                 // RG formats
1047                 GL_RG32I,
1048                 GL_RG32UI,
1049                 GL_RG16I,
1050                 GL_RG16UI,
1051                 GL_RG8,
1052                 GL_RG8I,
1053                 GL_RG8UI,
1054
1055                 // R formats
1056                 GL_R32I,
1057                 GL_R32UI,
1058                 GL_R16I,
1059                 GL_R16UI,
1060                 GL_R8,
1061                 GL_R8I,
1062                 GL_R8UI,
1063
1064                 // GL_EXT_color_buffer_float
1065                 GL_RGBA32F,
1066                 GL_RGBA16F,
1067                 GL_R11F_G11F_B10F,
1068                 GL_RG32F,
1069                 GL_RG16F,
1070                 GL_R32F,
1071                 GL_R16F,
1072
1073                 // GL_EXT_color_buffer_half_float
1074                 GL_RGB16F
1075         };
1076
1077         // .clear
1078         {
1079                 tcu::TestCaseGroup* clearGroup = new tcu::TestCaseGroup(m_testCtx, "clear", "Color clears");
1080                 addChild(clearGroup);
1081
1082                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(colorFormats); ndx++)
1083                         clearGroup->addChild(new FboColorClearCase(m_context, getFormatName(colorFormats[ndx]), "", colorFormats[ndx], 129, 117));
1084         }
1085
1086         // .tex2d
1087         {
1088                 tcu::TestCaseGroup* tex2DGroup = new tcu::TestCaseGroup(m_testCtx, "tex2d", "Texture 2D tests");
1089                 addChild(tex2DGroup);
1090
1091                 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1092                         tex2DGroup->addChild(new FboColorMultiTex2DCase(m_context, getFormatName(colorFormats[fmtNdx]), "",
1093                                                                                                                         colorFormats[fmtNdx], IVec2(129, 117),
1094                                                                                                                         colorFormats[fmtNdx], IVec2(99, 128)));
1095         }
1096
1097         // .texcube
1098         {
1099                 tcu::TestCaseGroup* texCubeGroup = new tcu::TestCaseGroup(m_testCtx, "texcube", "Texture cube map tests");
1100                 addChild(texCubeGroup);
1101
1102                 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1103                         texCubeGroup->addChild(new FboColorTexCubeCase(m_context, getFormatName(colorFormats[fmtNdx]), "",
1104                                                                                                                    colorFormats[fmtNdx], IVec2(128, 128)));
1105         }
1106
1107         // .tex2darray
1108         {
1109                 tcu::TestCaseGroup* tex2DArrayGroup = new tcu::TestCaseGroup(m_testCtx, "tex2darray", "Texture 2D array tests");
1110                 addChild(tex2DArrayGroup);
1111
1112                 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1113                         tex2DArrayGroup->addChild(new FboColorTex2DArrayCase(m_context, getFormatName(colorFormats[fmtNdx]), "",
1114                                                                                                                                  colorFormats[fmtNdx], IVec3(128, 128, 5)));
1115         }
1116
1117         // .tex3d
1118         {
1119                 tcu::TestCaseGroup* tex3DGroup = new tcu::TestCaseGroup(m_testCtx, "tex3d", "Texture 3D tests");
1120                 addChild(tex3DGroup);
1121
1122                 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1123                         tex3DGroup->addChild(new FboColorTex3DCase(m_context, getFormatName(colorFormats[fmtNdx]), "",
1124                                                                                                            colorFormats[fmtNdx], IVec3(128, 128, 5)));
1125         }
1126
1127         // .blend
1128         {
1129                 tcu::TestCaseGroup* blendGroup = new tcu::TestCaseGroup(m_testCtx, "blend", "Blending tests");
1130                 addChild(blendGroup);
1131
1132                 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1133                 {
1134                         deUint32                                        format          = colorFormats[fmtNdx];
1135                         tcu::TextureFormat                      texFmt          = glu::mapGLInternalFormat(format);
1136                         tcu::TextureChannelClass        fmtClass        = tcu::getTextureChannelClass(texFmt.type);
1137                         string                                          fmtName         = getFormatName(format);
1138
1139                         if (texFmt.type == tcu::TextureFormat::FLOAT                            ||
1140                                 fmtClass        == tcu::TEXTURECHANNELCLASS_SIGNED_INTEGER      ||
1141                                 fmtClass        == tcu::TEXTURECHANNELCLASS_UNSIGNED_INTEGER)
1142                                 continue; // Blending is not supported.
1143
1144                         blendGroup->addChild(new FboBlendCase(m_context, (fmtName + "_src_over").c_str(), "", format, IVec2(127, 111), GL_FUNC_ADD, GL_FUNC_ADD, GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ZERO, GL_ONE));
1145                 }
1146         }
1147
1148         // .repeated_clear
1149         {
1150                 tcu::TestCaseGroup* const repeatedClearGroup = new tcu::TestCaseGroup(m_testCtx, "repeated_clear", "Repeated clears and blits");
1151                 addChild(repeatedClearGroup);
1152
1153                 // .sample.tex2d
1154                 {
1155                         tcu::TestCaseGroup* const sampleGroup = new tcu::TestCaseGroup(m_testCtx, "sample", "Read by sampling");
1156                         repeatedClearGroup->addChild(sampleGroup);
1157
1158                         tcu::TestCaseGroup* const tex2DGroup = new tcu::TestCaseGroup(m_testCtx, "tex2d", "2D Texture");
1159                         sampleGroup->addChild(tex2DGroup);
1160
1161                         for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1162                                 tex2DGroup->addChild(new FboRepeatedClearSampleTex2DCase(m_context, getFormatName(colorFormats[fmtNdx]),
1163                                                                                                                                                  "", colorFormats[fmtNdx]));
1164                 }
1165
1166                 // .blit
1167                 {
1168                         tcu::TestCaseGroup* const blitGroup = new tcu::TestCaseGroup(m_testCtx, "blit", "Blitted");
1169                         repeatedClearGroup->addChild(blitGroup);
1170
1171                         // .tex2d
1172                         {
1173                                 tcu::TestCaseGroup* const tex2DGroup = new tcu::TestCaseGroup(m_testCtx, "tex2d", "2D Texture");
1174                                 blitGroup->addChild(tex2DGroup);
1175
1176                                 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1177                                         tex2DGroup->addChild(new FboRepeatedClearBlitTex2DCase(m_context, getFormatName(colorFormats[fmtNdx]),
1178                                                                                                                                                    "", colorFormats[fmtNdx]));
1179                         }
1180
1181                         // .rbo
1182                         {
1183                                 tcu::TestCaseGroup* const rboGroup = new tcu::TestCaseGroup(m_testCtx, "rbo", "Renderbuffer");
1184                                 blitGroup->addChild(rboGroup);
1185
1186                                 for (int fmtNdx = 0; fmtNdx < DE_LENGTH_OF_ARRAY(colorFormats); fmtNdx++)
1187                                         rboGroup->addChild(new FboRepeatedClearBlitRboCase(m_context, getFormatName(colorFormats[fmtNdx]),
1188                                                                                                                                            "", colorFormats[fmtNdx]));
1189                         }
1190                 }
1191         }
1192 }
1193
1194 } // Functional
1195 } // gles3
1196 } // deqp