external/openglcts/modules/gl/gl4cPostDepthCoverageTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   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
  22  */ /*-------------------------------------------------------------------*/
  23
  24 /**
  25  */ /*!
  26  * \file  gl4cPostDepthCoverageTests.cpp
  27  * \brief Conformance tests for the GL_ARB_post_depth_coverage functionality.
  28  */ /*-------------------------------------------------------------------*/
  29
  30 #include "gl4cPostDepthCoverageTests.hpp"
  31 #include "gluContextInfo.hpp"
  32 #include "gluDefs.hpp"
  33 #include "gluDrawUtil.hpp"
  34 #include "gluShaderProgram.hpp"
  35 #include "glwEnums.hpp"
  36 #include "glwFunctions.hpp"
  37 #include "tcuTestLog.hpp"
  38
  39 using namespace glw;
  40 using namespace glu;
  41
  42 namespace gl4cts
  43 {
  44 static const char* c_commonVertShader = "#version 450\n"
  45                                                                                 "\n"
  46                                                                                 "in vec3 vertex;\n"
  47                                                                                 "in vec2 inTexCoord;\n"
  48                                                                                 "out vec2 texCoord;\n"
  49                                                                                 "\n"
  50                                                                                 "void main()\n"
  51                                                                                 "{\n"
  52                                                                                 "    texCoord = inTexCoord;\n"
  53                                                                                 "    gl_Position = vec4(vertex, 1);\n"
  54                                                                                 "}\n";
  55
  56 /** Constructor.
  57  *
  58  *  @param context     Rendering context
  59  */
  60 PostDepthShaderCase::PostDepthShaderCase(deqp::Context& context)
  61         : TestCase(context, "PostDepthShader",
  62                            "Verifies if shader functionality added in ARB_post_depth_coverage extension works as expected")
  63 {
  64         /* Left blank intentionally */
  65 }
  66
  67 /** Stub deinit method. */
  68 void PostDepthShaderCase::deinit()
  69 {
  70 }
  71
  72 /** Stub init method */
  73 void PostDepthShaderCase::init()
  74 {
  75         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_post_depth_coverage"))
  76                 throw tcu::NotSupportedError("GL_ARB_post_depth_coverage not supported");
  77
  78         m_vertShader = c_commonVertShader;
  79
  80         m_fragShader1 = "#version 450\n"
  81                                         "\n"
  82                                         "#extension GL_ARB_post_depth_coverage : require\n"
  83                                         "\n"
  84                                         "out vec4 fragColor;\n"
  85                                         "\n"
  86                                         "void main()\n"
  87                                         "{\n"
  88                                         "    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
  89                                         "}\n";
  90
  91         m_fragShader2 = "#version 450\n"
  92                                         "\n"
  93                                         "#extension GL_ARB_post_depth_coverage : enable\n"
  94                                         "\n"
  95                                         "#ifndef GL_ARB_post_depth_coverage\n"
  96                                         "  #error GL_ARB_post_depth_coverage not defined\n"
  97                                         "#else\n"
  98                                         "  #if (GL_ARB_post_depth_coverage != 1)\n"
  99                                         "    #error GL_ARB_post_depth_coverage wrong defined\n"
 100                                         "  #endif\n"
 101                                         "#endif // GL_ARB_post_depth_coverage\n"
 102                                         "\n"
 103                                         "out vec4 fragColor;\n"
 104                                         "\n"
 105                                         "void main()\n"
 106                                         "{\n"
 107                                         "    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
 108                                         "}\n";
 109
 110         m_fragShader3 = "#version 450\n"
 111                                         "\n"
 112                                         "#extension GL_ARB_post_depth_coverage : enable\n"
 113                                         "\n"
 114                                         "layout(early_fragment_tests) in;\n"
 115                                         "layout(post_depth_coverage) in;\n"
 116                                         "\n"
 117                                         "out vec4 fragColor;\n"
 118                                         "\n"
 119                                         "void main()\n"
 120                                         "{\n"
 121                                         "    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
 122                                         "}\n";
 123
 124         m_fragShader4 = "#version 450\n"
 125                                         "\n"
 126                                         "#extension GL_ARB_post_depth_coverage : enable\n"
 127                                         "\n"
 128                                         "layout(post_depth_coverage) in;\n"
 129                                         "\n"
 130                                         "out vec4 fragColor;\n"
 131                                         "\n"
 132                                         "void main()\n"
 133                                         "{\n"
 134                                         "    fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n"
 135                                         "}\n";
 136 }
 137
 138 /** Executes test iteration.
 139  *
 140  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 141  */
 142 tcu::TestNode::IterateResult PostDepthShaderCase::iterate()
 143 {
 144         const Functions& gl = m_context.getRenderContext().getFunctions();
 145
 146         ProgramSources sources1 = makeVtxFragSources(m_vertShader, m_fragShader1);
 147         ShaderProgram  program1(gl, sources1);
 148
 149         if (!program1.isOk())
 150         {
 151                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking extension in shader");
 152                 m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program1.getShaderInfo(SHADERTYPE_VERTEX).infoLog
 153                                                    << "\n"
 154                                                    << "Fragment: " << program1.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 155                                                    << "Program: " << program1.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 156
 157                 return STOP;
 158         }
 159
 160         ProgramSources sources2 = makeVtxFragSources(m_vertShader, m_fragShader2);
 161         ShaderProgram  program2(gl, sources2);
 162
 163         if (!program2.isOk())
 164         {
 165                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking preprocessor directives in shader");
 166                 m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program2.getShaderInfo(SHADERTYPE_VERTEX).infoLog
 167                                                    << "\n"
 168                                                    << "Fragment: " << program2.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 169                                                    << "Program: " << program2.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 170                 return STOP;
 171         }
 172
 173         ProgramSources sources3 = makeVtxFragSources(m_vertShader, m_fragShader3);
 174         ShaderProgram  program3(gl, sources3);
 175
 176         if (!program3.isOk())
 177         {
 178                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking first layout setup in shader");
 179                 m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program3.getShaderInfo(SHADERTYPE_VERTEX).infoLog
 180                                                    << "\n"
 181                                                    << "Fragment: " << program3.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 182                                                    << "Program: " << program3.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 183                 return STOP;
 184         }
 185
 186         ProgramSources sources4 = makeVtxFragSources(m_vertShader, m_fragShader4);
 187         ShaderProgram  program4(gl, sources4);
 188
 189         if (!program4.isOk())
 190         {
 191                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail checking second layout setup in shader");
 192                 m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program4.getShaderInfo(SHADERTYPE_VERTEX).infoLog
 193                                                    << "\n"
 194                                                    << "Fragment: " << program4.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 195                                                    << "Program: " << program4.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 196                 return STOP;
 197         }
 198
 199         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 200         return STOP;
 201 }
 202
 203 /** Constructor.
 204  *
 205  *  @param context     Rendering context
 206  */
 207 PostDepthSampleMaskCase::PostDepthSampleMaskCase(deqp::Context& context)
 208         : TestCase(context, "PostDepthSampleMask", "Verifies multisampling with depth test and stencil test functionality "
 209                                                                                            "added in ARB_post_depth_coverage extension")
 210         , m_framebufferMS(0)
 211         , m_framebuffer(0)
 212         , m_textureMS(0)
 213         , m_texture(0)
 214         , m_depthStencilRenderbuffer(0)
 215 {
 216         /* Left blank intentionally */
 217 }
 218
 219 /** Stub deinit method. */
 220 void PostDepthSampleMaskCase::deinit()
 221 {
 222         const Functions& gl = m_context.getRenderContext().getFunctions();
 223
 224         gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
 225
 226         if (m_framebufferMS)
 227                 gl.deleteFramebuffers(1, &m_framebufferMS);
 228         if (m_framebuffer)
 229                 gl.deleteFramebuffers(1, &m_framebuffer);
 230
 231         if (m_textureMS)
 232                 gl.deleteTextures(1, &m_textureMS);
 233         if (m_texture)
 234                 gl.deleteTextures(1, &m_texture);
 235
 236         if (m_depthStencilRenderbuffer)
 237                 gl.deleteRenderbuffers(1, &m_depthStencilRenderbuffer);
 238 }
 239
 240 /** Stub init method */
 241 void PostDepthSampleMaskCase::init()
 242 {
 243         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_post_depth_coverage"))
 244                 throw tcu::NotSupportedError("GL_ARB_post_depth_coverage not supported");
 245
 246         m_vertShader = c_commonVertShader;
 247
 248         m_fragShader1a = "#version 450\n"
 249                                          "\n"
 250                                          "#extension GL_ARB_post_depth_coverage : enable\n"
 251                                          "\n"
 252                                          "in vec2 texCoord;\n"
 253                                          "out vec4 fragColor;\n"
 254                                          "\n"
 255                                          "void main()\n"
 256                                          "{\n"
 257                                          "    int samp1 = (gl_SampleMaskIn[0] & 0x1);\n"
 258                                          "    int samp2 = (gl_SampleMaskIn[0] & 0x2) / 2;\n"
 259                                          "    int samp3 = (gl_SampleMaskIn[0] & 0x4) / 4;\n"
 260                                          "    int samp4 = (gl_SampleMaskIn[0] & 0x8) / 8;\n"
 261                                          "    fragColor = vec4(samp1, samp2, samp3, samp4);\n"
 262                                          "}\n";
 263
 264         m_fragShader1b = "#version 450\n"
 265                                          "\n"
 266                                          "#extension GL_ARB_post_depth_coverage : enable\n"
 267                                          "layout(post_depth_coverage) in;\n"
 268                                          "\n"
 269                                          "in vec2 texCoord;\n"
 270                                          "out vec4 fragColor;\n"
 271                                          "\n"
 272                                          "void main()\n"
 273                                          "{\n"
 274                                          "    int samp1 = (gl_SampleMaskIn[0] & 0x1);\n"
 275                                          "    int samp2 = (gl_SampleMaskIn[0] & 0x2) / 2;\n"
 276                                          "    int samp3 = (gl_SampleMaskIn[0] & 0x4) / 4;\n"
 277                                          "    int samp4 = (gl_SampleMaskIn[0] & 0x8) / 8;\n"
 278                                          "    fragColor = vec4(samp1, samp2, samp3, samp4);\n"
 279                                          "}\n";
 280
 281         m_fragShader2 = "#version 450\n"
 282                                         "\n"
 283                                         "in vec2 texCoord;\n"
 284                                         "out vec4 fragColor;\n"
 285                                         "\n"
 286                                         "uniform sampler2DMS texture;\n"
 287                                         "\n"
 288                                         "void main()\n"
 289                                         "{\n"
 290                                         "    int samp = int(texCoord.y * 4);\n"
 291                                         "    fragColor = texelFetch(texture, ivec2(0, 0), samp);\n"
 292                                         "}\n";
 293
 294         const Functions& gl = m_context.getRenderContext().getFunctions();
 295
 296         gl.genRenderbuffers(1, &m_depthStencilRenderbuffer);
 297         gl.bindRenderbuffer(GL_RENDERBUFFER, m_depthStencilRenderbuffer);
 298         gl.renderbufferStorageMultisample(GL_RENDERBUFFER, 4, GL_DEPTH_STENCIL, 1, 1);
 299         GLU_EXPECT_NO_ERROR(gl.getError(), "glRenderbufferStorageMultisample");
 300
 301         gl.genTextures(1, &m_textureMS);
 302         gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_textureMS);
 303         gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, 4, GL_RGBA8, 1, 1, GL_TRUE);
 304         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2DMultisample");
 305
 306         gl.genFramebuffers(1, &m_framebufferMS);
 307         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebufferMS);
 308         gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, m_textureMS, 0);
 309         gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilRenderbuffer);
 310         gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_STENCIL_ATTACHMENT, GL_RENDERBUFFER, m_depthStencilRenderbuffer);
 311
 312         gl.genTextures(1, &m_texture);
 313         gl.bindTexture(GL_TEXTURE_2D, m_texture);
 314         gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, 1, 4);
 315
 316         gl.genFramebuffers(1, &m_framebuffer);
 317         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 318         gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_texture, 0);
 319 }
 320
 321 /** Executes test iteration.
 322  *
 323  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 324  */
 325 tcu::TestNode::IterateResult PostDepthSampleMaskCase::iterate()
 326 {
 327         const Functions& gl = m_context.getRenderContext().getFunctions();
 328
 329         const GLfloat texCoord[] = {
 330                 0.0f, 0.0f, 1.0f, 0.0f, 0.0f, 1.0f, 1.0f, 1.0f,
 331         };
 332
 333         const GLfloat verticesNear[] = {
 334                 -1.0f, -1.0f, 0.25f, 0.4f, -1.0f, 0.25f, -1.0f, 0.4f, 0.25f,
 335         };
 336
 337         const GLfloat verticesFar[] = {
 338                 -1.0f, -1.0f, 0.75f, 3.0f, -1.0f, 0.75f, -1.0f, 3.0f, 0.75f,
 339         };
 340
 341         const GLfloat verticesPost[] = {
 342                 -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f, -1.0f, 1.0f, 0.0f, 1.0f, 1.0f, 0.0f,
 343         };
 344
 345         const GLuint indicesPre[] = { 0, 1, 2 };
 346
 347         const GLuint indicesPost[] = { 0, 1, 2, 1, 2, 3 };
 348
 349         glu::VertexArrayBinding vertexArraysNear[] = { glu::va::Float("vertex", 3, 3, 0, verticesNear),
 350                                                                                                    glu::va::Float("inTexCoord", 2, 3, 0, texCoord) };
 351
 352         glu::VertexArrayBinding vertexArraysFar[] = { glu::va::Float("vertex", 3, 3, 0, verticesFar),
 353                                                                                                   glu::va::Float("inTexCoord", 2, 3, 0, texCoord) };
 354
 355         glu::VertexArrayBinding vertexArraysPost[] = { glu::va::Float("vertex", 3, 4, 0, verticesPost),
 356                                                                                                    glu::va::Float("inTexCoord", 2, 4, 0, texCoord) };
 357
 358         //Prepare shaders
 359         ProgramSources sources1a = makeVtxFragSources(m_vertShader, m_fragShader1a);
 360         ShaderProgram  program1a(gl, sources1a);
 361
 362         if (!program1a.isOk())
 363         {
 364                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader program fail (non post_depth_coverage).");
 365                 m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program1a.getShaderInfo(SHADERTYPE_VERTEX).infoLog
 366                                                    << "\n"
 367                                                    << "Fragment: " << program1a.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 368                                                    << "Program: " << program1a.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 369                 return STOP;
 370         }
 371
 372         ProgramSources sources1b = makeVtxFragSources(m_vertShader, m_fragShader1b);
 373         ShaderProgram  program1b(gl, sources1b);
 374
 375         if (!program1b.isOk())
 376         {
 377                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader program fail (post_depth_coverage).");
 378                 m_testCtx.getLog() << tcu::TestLog::Message << "PostDepthCoverage: enabled\n"
 379                                                    << "Vertex: " << program1b.getShaderInfo(SHADERTYPE_VERTEX).infoLog << "\n"
 380                                                    << "Fragment: " << program1b.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 381                                                    << "Program: " << program1b.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 382                 return STOP;
 383         }
 384
 385         ProgramSources sources2 = makeVtxFragSources(m_vertShader, m_fragShader2);
 386         ShaderProgram  program2(gl, sources2);
 387
 388         if (!program2.isOk())
 389         {
 390                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Shader program fail (samples reader).");
 391                 m_testCtx.getLog() << tcu::TestLog::Message << "Vertex: " << program2.getShaderInfo(SHADERTYPE_VERTEX).infoLog
 392                                                    << "\n"
 393                                                    << "Fragment: " << program2.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 394                                                    << "Program: " << program2.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 395                 return STOP;
 396         }
 397
 398         gl.clearColor(0.0f, 0.0f, 0.0f, 0.0f);
 399         gl.clearStencil(0);
 400
 401         //Iterate through all cases
 402         for (int bufferCase = BUFFERCASE_FIRST; bufferCase <= BUFFERCASE_LAST; ++bufferCase)
 403                 for (int pdcCase = PDCCASE_FIRST; pdcCase <= PDCCASE_LAST; ++pdcCase)
 404                 {
 405                         GLint program = 0;
 406                         if (pdcCase == PDCCASE_DISABLED)
 407                                 program = program1a.getProgram();
 408                         else if (pdcCase == PDCCASE_ENABLED)
 409                                 program = program1b.getProgram();
 410
 411                         gl.useProgram(program);
 412
 413                         //Firstible use multisampled framebuffer
 414                         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebufferMS);
 415                         gl.viewport(0, 0, 1, 1);
 416
 417                         gl.enable(GL_MULTISAMPLE);
 418
 419                         //Check which samples should be covered by first draw - calculate expected sample mask
 420                         GLboolean expectedMask[4];
 421
 422                         for (GLint i = 0; i < 4; ++i)
 423                         {
 424                                 GLfloat samplePos[2];
 425                                 gl.getMultisamplefv(GL_SAMPLE_POSITION, i, &samplePos[0]);
 426                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetMultisamplefv");
 427                                 if (pdcCase == PDCCASE_ENABLED && (samplePos[0] + samplePos[1]) < 0.7f)
 428                                         expectedMask[i] = false;
 429                                 else
 430                                         expectedMask[i] = true;
 431                         }
 432
 433                         if (bufferCase == BUFFERCASE_DEPTH)
 434                                 gl.enable(GL_DEPTH_TEST);
 435                         else if (bufferCase == BUFFERCASE_STENCIL)
 436                                 gl.enable(GL_STENCIL_TEST);
 437
 438                         gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 439
 440                         if (bufferCase == BUFFERCASE_STENCIL)
 441                         {
 442                                 gl.stencilFunc(GL_ALWAYS, 1, 0xFF);
 443                                 gl.stencilOp(GL_ZERO, GL_REPLACE, GL_REPLACE);
 444                                 gl.stencilMask(0xFF);
 445                         }
 446
 447                         //Draw near primitive
 448                         glu::draw(m_context.getRenderContext(), program, DE_LENGTH_OF_ARRAY(vertexArraysNear), vertexArraysNear,
 449                                           glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indicesPre), indicesPre));
 450
 451                         gl.clear(GL_COLOR_BUFFER_BIT);
 452
 453                         if (bufferCase == BUFFERCASE_STENCIL)
 454                         {
 455                                 gl.stencilFunc(GL_NOTEQUAL, 1, 0xFF);
 456                                 gl.stencilMask(0x00);
 457                         }
 458
 459                         //Draw far primitive
 460                         glu::draw(m_context.getRenderContext(), program, DE_LENGTH_OF_ARRAY(vertexArraysFar), vertexArraysFar,
 461                                           glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indicesPre), indicesPre));
 462
 463                         gl.disable(GL_DEPTH_TEST);
 464                         if (bufferCase == BUFFERCASE_DEPTH)
 465                                 gl.disable(GL_DEPTH_TEST);
 466                         else if (bufferCase == BUFFERCASE_STENCIL)
 467                                 gl.disable(GL_STENCIL_TEST);
 468
 469                         gl.bindFramebuffer(GL_FRAMEBUFFER, 0);
 470
 471                         gl.useProgram(program2.getProgram());
 472
 473                         gl.bindFramebuffer(GL_FRAMEBUFFER, m_framebuffer);
 474                         gl.viewport(0, 0, 1, 4);
 475
 476                         //Pass multisampled texture as a uniform
 477                         gl.activeTexture(GL_TEXTURE0);
 478                         gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, m_textureMS);
 479                         gl.uniform1i(gl.getUniformLocation(program2.getProgram(), "texture"), 0);
 480
 481                         gl.clear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
 482
 483                         //Draw multisampled texture to framebuffer
 484                         glu::draw(m_context.getRenderContext(), program2.getProgram(), DE_LENGTH_OF_ARRAY(vertexArraysPost),
 485                                           vertexArraysPost, glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(indicesPost), indicesPost));
 486
 487                         gl.disable(GL_MULTISAMPLE);
 488
 489                         //Read data from framebuffer
 490                         GLubyte pixels[4 * 4];
 491                         deMemset(pixels, 0, 4 * 4);
 492
 493                         gl.readPixels(0, 0, 1, 4, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
 494                         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels");
 495
 496                         //Verify the result
 497                         GLboolean compiledMask[4];
 498                         deMemset(compiledMask, 0, 4);
 499                         for (int i = 0; i < 4; ++i)
 500                         {
 501                                 for (int n                      = 0; n < 4; ++n)
 502                                         compiledMask[n] = compiledMask[n] || (pixels[4 * i + n] != 0);
 503                         }
 504
 505                         for (int n = 0; n < 4; ++n)
 506                         {
 507                                 if (expectedMask[n] != compiledMask[n])
 508                                 {
 509                                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 510                                         m_testCtx.getLog() << tcu::TestLog::Message << "Wrong results for "
 511                                                                            << (bufferCase == BUFFERCASE_DEPTH ? "BUFFERCASE_DEPTH" :
 512                                                                                                                                                         "BUFFERCASE_DEPTH_STENCIL")
 513                                                                            << " / "
 514                                                                            << (pdcCase == PDCCASE_DISABLED ? "PDCCASE_DISABLED" : "PDCCASE_ENABLED")
 515                                                                            << tcu::TestLog::EndMessage;
 516                                         return STOP;
 517                                 }
 518                         }
 519                 }
 520
 521         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 522         return STOP;
 523 }
 524
 525 /** Constructor.
 526  *
 527  *  @param context Rendering context.
 528  */
 529 PostDepthCoverage::PostDepthCoverage(deqp::Context& context)
 530         : TestCaseGroup(context, "post_depth_coverage_tests",
 531                                         "Verify conformance of CTS_ARB_post_depth_coverage implementation")
 532 {
 533 }
 534
 535 /** Initializes the test group contents. */
 536 void PostDepthCoverage::init()
 537 {
 538         addChild(new PostDepthShaderCase(m_context));
 539         addChild(new PostDepthSampleMaskCase(m_context));
 540 }
 541
 542 } /* gl4cts namespace */