external/openglcts/modules/gl/gl3cCullDistanceTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2015-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  gl3cCullDistanceTests.cpp
  27  * \brief Cull Distance Test Suite Implementation
  28  */ /*-------------------------------------------------------------------*/
  29
  30 #include "gl3cCullDistanceTests.hpp"
  31 #include "gluContextInfo.hpp"
  32 #include "gluDefs.hpp"
  33 #include "gluStrUtil.hpp"
  34 #include "glwEnums.hpp"
  35 #include "glwFunctions.hpp"
  36 #include "tcuRenderTarget.hpp"
  37 #include "tcuTestLog.hpp"
  38
  39 #include <cmath>
  40 #include <sstream>
  41 #include <string>
  42 #include <vector>
  43
  44 #ifndef GL_MAX_CULL_DISTANCES
  45 #define GL_MAX_CULL_DISTANCES (0x82F9)
  46 #endif
  47 #ifndef GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES
  48 #define GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES (0x82FA)
  49 #endif
  50
  51 namespace glcts
  52 {
  53 /** @brief Build OpenGL program
  54  *
  55  *  @param [in]  gl             OpenGL function bindings
  56  *  @param [in]  testCtx        Context
  57  *  @param [in]  cs_body        Compute shader source code
  58  *  @param [in]  fs_body        Fragment shader source code
  59  *  @param [in]  gs_body        Geometric shader source code
  60  *  @param [in]  tc_body        Tessellation control shader source code
  61  *  @param [in]  te_body        Tessellation evaluation shader source code
  62  *  @param [in]  vs_body        Vertex shader source code
  63  *  @param [in]  n_tf_varyings  Number of transform feedback varyings
  64  *  @param [in]  tf_varyings    Transform feedback varyings names
  65  *
  66  *  @param [out] out_program    If succeeded output program GL handle, 0 otherwise.
  67  */
  68 void CullDistance::Utilities::buildProgram(const glw::Functions& gl, tcu::TestContext& testCtx,
  69                                                                                    const glw::GLchar* cs_body, const glw::GLchar* fs_body,
  70                                                                                    const glw::GLchar* gs_body, const glw::GLchar* tc_body,
  71                                                                                    const glw::GLchar* te_body, const glw::GLchar* vs_body,
  72                                                                                    const glw::GLuint& n_tf_varyings, const glw::GLchar** tf_varyings,
  73                                                                                    glw::GLuint* out_program)
  74 {
  75         glw::GLuint po_id = 0;
  76
  77         struct _shaders_configuration
  78         {
  79                 glw::GLenum                type;
  80                 const glw::GLchar* body;
  81                 glw::GLuint                id;
  82         } shaders_configuration[] = { { GL_COMPUTE_SHADER, cs_body, 0 },                 { GL_FRAGMENT_SHADER, fs_body, 0 },
  83                                                                   { GL_GEOMETRY_SHADER, gs_body, 0 },            { GL_TESS_CONTROL_SHADER, tc_body, 0 },
  84                                                                   { GL_TESS_EVALUATION_SHADER, te_body, 0 }, { GL_VERTEX_SHADER, vs_body, 0 } };
  85
  86         const glw::GLuint n_shaders_configuration = sizeof(shaders_configuration) / sizeof(shaders_configuration[0]);
  87
  88         /* Guard allocated OpenGL resources */
  89         try
  90         {
  91                 /* Create needed programs */
  92                 po_id = gl.createProgram();
  93                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() call failed.");
  94
  95                 for (glw::GLuint n_shader_index = 0; n_shader_index < n_shaders_configuration; n_shader_index++)
  96                 {
  97                         if (shaders_configuration[n_shader_index].body != DE_NULL)
  98                         {
  99                                 /* Generate shader object */
 100                                 shaders_configuration[n_shader_index].id = gl.createShader(shaders_configuration[n_shader_index].type);
 101                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateShader() call failed");
 102
 103                                 glw::GLint                compile_status = GL_FALSE;
 104                                 const glw::GLuint so_id                  = shaders_configuration[n_shader_index].id;
 105
 106                                 /* Assign shader source code */
 107                                 gl.shaderSource(shaders_configuration[n_shader_index].id, 1,               /* count */
 108                                                                 &shaders_configuration[n_shader_index].body, DE_NULL); /* length */
 109                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed");
 110
 111                                 gl.compileShader(so_id);
 112                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed.");
 113
 114                                 gl.getShaderiv(so_id, GL_COMPILE_STATUS, &compile_status);
 115                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
 116
 117                                 if (compile_status == GL_FALSE)
 118                                 {
 119                                         std::vector<glw::GLchar> log_array(1);
 120                                         glw::GLint                               log_length = 0;
 121                                         std::string                              log_string("Failed to retrieve log");
 122
 123                                         /* Retrive compilation log length */
 124                                         gl.getShaderiv(so_id, GL_INFO_LOG_LENGTH, &log_length);
 125                                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
 126
 127                                         log_array.resize(log_length + 1, 0);
 128
 129                                         gl.getShaderInfoLog(so_id, log_length, DE_NULL, &log_array[0]);
 130                                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed.");
 131
 132                                         log_string = std::string(&log_array[0]);
 133
 134                                         testCtx.getLog() << tcu::TestLog::Message << "Shader compilation has failed.\n"
 135                                                                          << "Shader type: " << shaders_configuration[n_shader_index].type << "\n"
 136                                                                          << "Shader compilation error log:\n"
 137                                                                          << log_string << "\n"
 138                                                                          << "Shader source code:\n"
 139                                                                          << shaders_configuration[n_shader_index].body << "\n"
 140                                                                          << tcu::TestLog::EndMessage;
 141
 142                                         TCU_FAIL("Shader compilation has failed.");
 143                                 }
 144
 145                                 /* Also attach the shader to the corresponding program object */
 146                                 gl.attachShader(po_id, so_id);
 147
 148                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call failed");
 149                         } /* if (shaders_configuration[n_shader_index].body != DE_NULL) */
 150                 }        /* for (all shader object IDs) */
 151
 152                 /* Set transform feedback if requested */
 153                 if (n_tf_varyings > 0)
 154                 {
 155                         gl.transformFeedbackVaryings(po_id, n_tf_varyings, tf_varyings, GL_INTERLEAVED_ATTRIBS);
 156                         GLU_EXPECT_NO_ERROR(gl.getError(), "glTransformFeedbackVaryings() call failed");
 157                 }
 158
 159                 /* Try to link the program objects */
 160                 if (po_id != 0)
 161                 {
 162                         glw::GLint link_status = GL_FALSE;
 163
 164                         gl.linkProgram(po_id);
 165                         GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed");
 166
 167                         gl.getProgramiv(po_id, GL_LINK_STATUS, &link_status);
 168                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed");
 169
 170                         if (link_status == GL_FALSE)
 171                         {
 172                                 std::vector<glw::GLchar> log_array(1);
 173                                 glw::GLsizei                     log_length = 0;
 174                                 std::string                              log_string;
 175
 176                                 /* Retreive compilation log length */
 177                                 gl.getProgramiv(po_id, GL_INFO_LOG_LENGTH, &log_length);
 178                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
 179
 180                                 log_array.resize(log_length + 1, 0);
 181
 182                                 /* Retreive compilation log */
 183                                 gl.getProgramInfoLog(po_id, log_length, DE_NULL, &log_array[0]);
 184                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog() call failed.");
 185
 186                                 log_string = std::string(&log_array[0]);
 187
 188                                 /* Log linking error message */
 189                                 testCtx.getLog() << tcu::TestLog::Message << "Program linking has failed.\n"
 190                                                                  << "Linking error log:\n"
 191                                                                  << log_string << "\n"
 192                                                                  << tcu::TestLog::EndMessage;
 193
 194                                 /* Log shader source code of shaders involved */
 195                                 for (glw::GLuint n_shader_index = 0; n_shader_index < n_shaders_configuration; n_shader_index++)
 196                                 {
 197                                         if (shaders_configuration[n_shader_index].body != DE_NULL)
 198                                         {
 199                                                 testCtx.getLog() << tcu::TestLog::Message << "Shader source code of type "
 200                                                                                  << shaders_configuration[n_shader_index].type << " follows:\n"
 201                                                                                  << shaders_configuration[n_shader_index].body << "\n"
 202                                                                                  << tcu::TestLog::EndMessage;
 203                                         }
 204                                 }
 205
 206                                 TCU_FAIL("Program linking failed");
 207                         }
 208                 } /* if (po_id != 0) */
 209
 210                 /* Delete all shaders we've created */
 211                 for (glw::GLuint n_shader_index = 0; n_shader_index < n_shaders_configuration; n_shader_index++)
 212                 {
 213                         const glw::GLuint so_id = shaders_configuration[n_shader_index].id;
 214
 215                         if (so_id != 0)
 216                         {
 217                                 gl.deleteShader(so_id);
 218
 219                                 shaders_configuration[n_shader_index].id = 0;
 220
 221                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDeleteShader() call failed.");
 222                         }
 223                 }
 224
 225                 /* Store the result progrtam IDs */
 226                 *out_program = po_id;
 227         }
 228         catch (...)
 229         {
 230                 /* Delete all shaders we've created */
 231                 for (glw::GLuint n_shader_index = 0; n_shader_index < n_shaders_configuration; n_shader_index++)
 232                 {
 233                         const glw::GLuint so_id = shaders_configuration[n_shader_index].id;
 234
 235                         if (so_id != 0)
 236                         {
 237                                 gl.deleteShader(so_id);
 238
 239                                 shaders_configuration[n_shader_index].id = 0;
 240                         }
 241                 }
 242
 243                 /* Delete the program object */
 244                 if (po_id != 0)
 245                 {
 246                         gl.deleteProgram(po_id);
 247
 248                         po_id = 0;
 249                 }
 250
 251                 /* Rethrow */
 252                 throw;
 253         }
 254 }
 255
 256 /** @brief Replace all occurences of a substring in a string by a substring
 257  *
 258  *  @param [in,out] str    string to be edited
 259  *  @param [in]     from   substring to be replaced
 260  *  @param [out]    to     new substring
 261  */
 262 void CullDistance::Utilities::replaceAll(std::string& str, const std::string& from, const std::string& to)
 263 {
 264         for (size_t start_pos = str.find(from, 0); start_pos != std::string::npos; start_pos = str.find(from, start_pos))
 265         {
 266                 str.replace(start_pos, from.length(), to);
 267
 268                 start_pos += to.length();
 269         }
 270
 271         return;
 272 }
 273
 274 /** @brief Convert integer to string representation
 275  *
 276  *  @param [in] integer     input integer to be converted
 277  *
 278  *  @return String representation of integer
 279  */
 280 std::string CullDistance::Utilities::intToString(glw::GLint integer)
 281 {
 282         std::stringstream temp_sstream;
 283
 284         temp_sstream << integer;
 285
 286         return temp_sstream.str();
 287 }
 288
 289 /** Constructor.
 290  *
 291  *  @param context Rendering context handle.
 292  **/
 293 CullDistance::APICoverageTest::APICoverageTest(deqp::Context& context)
 294         : TestCase(context, "coverage", "Cull Distance API Coverage Test")
 295         , m_bo_id(0)
 296         , m_cs_id(0)
 297         , m_cs_to_id(0)
 298         , m_fbo_draw_id(0)
 299         , m_fbo_draw_to_id(0)
 300         , m_fbo_read_id(0)
 301         , m_fs_id(0)
 302         , m_gs_id(0)
 303         , m_po_id(0)
 304         , m_tc_id(0)
 305         , m_te_id(0)
 306         , m_vao_id(0)
 307         , m_vs_id(0)
 308 {
 309         /* Left blank on purpose */
 310 }
 311
 312 /** @brief Cull Distance API Coverage Test deinitialization */
 313 void CullDistance::APICoverageTest::deinit()
 314 {
 315         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 316
 317         if (m_bo_id != 0)
 318         {
 319                 gl.deleteBuffers(1, &m_bo_id);
 320
 321                 m_bo_id = 0;
 322         }
 323
 324         if (m_cs_id != 0)
 325         {
 326                 gl.deleteShader(m_cs_id);
 327
 328                 m_cs_id = 0;
 329         }
 330
 331         if (m_cs_to_id != 0)
 332         {
 333                 gl.deleteTextures(1, &m_cs_to_id);
 334
 335                 m_cs_to_id = 0;
 336         }
 337
 338         if (m_fbo_draw_id != 0)
 339         {
 340                 gl.deleteFramebuffers(1, &m_fbo_draw_id);
 341
 342                 m_fbo_draw_id = 0;
 343         }
 344
 345         if (m_fbo_draw_to_id != 0)
 346         {
 347                 gl.deleteTextures(1, &m_fbo_draw_to_id);
 348
 349                 m_fbo_draw_to_id = 0;
 350         }
 351
 352         if (m_fbo_read_id != 0)
 353         {
 354                 gl.deleteFramebuffers(1, &m_fbo_read_id);
 355
 356                 m_fbo_read_id = 0;
 357         }
 358
 359         if (m_fs_id != 0)
 360         {
 361                 gl.deleteShader(m_fs_id);
 362
 363                 m_fs_id = 0;
 364         }
 365
 366         if (m_gs_id != 0)
 367         {
 368                 gl.deleteShader(m_gs_id);
 369
 370                 m_gs_id = 0;
 371         }
 372
 373         if (m_po_id != 0)
 374         {
 375                 gl.deleteProgram(m_po_id);
 376
 377                 m_po_id = 0;
 378         }
 379
 380         if (m_tc_id != 0)
 381         {
 382                 gl.deleteShader(m_tc_id);
 383
 384                 m_tc_id = 0;
 385         }
 386
 387         if (m_te_id != 0)
 388         {
 389                 gl.deleteShader(m_te_id);
 390
 391                 m_te_id = 0;
 392         }
 393
 394         if (m_vao_id != 0)
 395         {
 396                 gl.deleteVertexArrays(1, &m_vao_id);
 397
 398                 m_vao_id = 0;
 399         }
 400
 401         if (m_vs_id != 0)
 402         {
 403                 gl.deleteShader(m_vs_id);
 404
 405                 m_vs_id = 0;
 406         }
 407
 408         /* Restore default pack alignment value */
 409         gl.pixelStorei(GL_PACK_ALIGNMENT, 4);
 410 }
 411
 412 /** Executes test iteration.
 413  *
 414  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 415  */
 416 tcu::TestNode::IterateResult CullDistance::APICoverageTest::iterate()
 417 {
 418         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 419
 420         /* This test should only be executed if ARB_cull_distance is supported, or if
 421          * we're running a GL4.5 context
 422          */
 423         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_cull_distance") &&
 424                 !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)))
 425         {
 426                 throw tcu::NotSupportedError("GL_ARB_cull_distance is not supported");
 427         }
 428
 429         /* Check that calling GetIntegerv with MAX_CULL_DISTANCES doesn't generate
 430          * any errors and returns a value at least 8.
 431          *
 432          * Check that calling GetIntegerv with MAX_COMBINED_CLIP_AND_CULL_DISTANCES
 433          * doesn't generate any errors and returns a value at least 8.
 434          *
 435          */
 436         glw::GLint error_code                                                                    = GL_NO_ERROR;
 437         glw::GLint gl_max_cull_distances_value                                   = 0;
 438         glw::GLint gl_max_combined_clip_and_cull_distances_value = 0;
 439
 440         gl.getIntegerv(GL_MAX_CULL_DISTANCES, &gl_max_cull_distances_value);
 441
 442         error_code = gl.getError();
 443         if (error_code != GL_NO_ERROR)
 444         {
 445                 m_testCtx.getLog() << tcu::TestLog::Message << "glGetIntegerv() returned error code "
 446                                                    << "[" << glu::getErrorStr(error_code) << "] for GL_MAX_CULL_DISTANCES"
 447                                                                                                                                          " query instead of GL_NO_ERROR"
 448                                                    << tcu::TestLog::EndMessage;
 449
 450                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 451
 452                 return STOP;
 453         }
 454
 455         gl.getIntegerv(GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES, &gl_max_combined_clip_and_cull_distances_value);
 456
 457         error_code = gl.getError();
 458         if (error_code != GL_NO_ERROR)
 459         {
 460                 m_testCtx.getLog() << tcu::TestLog::Message << "glGetIntegerv() returned error code "
 461                                                    << "[" << glu::getErrorStr(error_code) << "] for "
 462                                                                                                                                          "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES query "
 463                                                                                                                                          "instead of GL_NO_ERROR"
 464                                                    << tcu::TestLog::EndMessage;
 465
 466                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 467
 468                 return STOP;
 469         }
 470
 471         /* Before we proceed with the two other tests, initialize a buffer & a texture
 472          * object we will need to capture data from the programs */
 473         static const glw::GLuint bo_size = sizeof(int) * 4 /* components */ * 4 /* result points */;
 474
 475         gl.genBuffers(1, &m_bo_id);
 476         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed.");
 477
 478         gl.genFramebuffers(1, &m_fbo_draw_id);
 479         gl.genFramebuffers(1, &m_fbo_read_id);
 480         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call(s) failed.");
 481
 482         gl.genTextures(1, &m_cs_to_id);
 483         gl.genTextures(1, &m_fbo_draw_to_id);
 484         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed.");
 485
 486         gl.genVertexArrays(1, &m_vao_id);
 487         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");
 488
 489         gl.bindVertexArray(m_vao_id);
 490         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
 491
 492         gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_bo_id);
 493         gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* index */
 494                                           m_bo_id);
 495         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() or glBindBufferBase() call(s) failed.");
 496
 497         gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, bo_size, DE_NULL, GL_STATIC_DRAW);
 498         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");
 499
 500         for (glw::GLuint n_to_id = 0; n_to_id < 2; /* CS, FBO */ ++n_to_id)
 501         {
 502                 gl.bindTexture(GL_TEXTURE_2D, (n_to_id == 0) ? m_cs_to_id : m_fbo_draw_to_id);
 503                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed.");
 504
 505                 gl.texStorage2D(GL_TEXTURE_2D, 1, /* levels */
 506                                                 GL_R32I, 1,               /* width */
 507                                                 1);                               /* height */
 508                 GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed.");
 509         }
 510
 511         gl.bindImageTexture(0,                     /* unit */
 512                                                 m_cs_to_id, 0, /* level */
 513                                                 GL_FALSE,         /* layered */
 514                                                 0,                         /* layer */
 515                                                 GL_WRITE_ONLY, GL_R32I);
 516         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindImageTexture() call failed.");
 517
 518         gl.bindFramebuffer(GL_DRAW_FRAMEBUFFER, m_fbo_draw_id);
 519         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed.");
 520
 521         gl.framebufferTexture2D(GL_DRAW_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_fbo_draw_to_id, 0); /* level */
 522         GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed.");
 523
 524         gl.bindFramebuffer(GL_READ_FRAMEBUFFER, m_fbo_read_id);
 525         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed.");
 526
 527         gl.viewport(0,  /* x */
 528                                 0,  /* y */
 529                                 1,  /* width */
 530                                 1); /* height */
 531         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed.");
 532
 533         gl.pixelStorei(GL_PACK_ALIGNMENT, 1);
 534         GLU_EXPECT_NO_ERROR(gl.getError(), "glPixelStorei() call failed.");
 535
 536         /* There are two new GL constants, where value we need to verify */
 537         struct _run
 538         {
 539                 const glw::GLchar* essl_token_value;
 540                 glw::GLenum                gl_enum;
 541                 glw::GLint                 gl_value;
 542                 glw::GLint                 min_value;
 543                 const glw::GLchar* name;
 544         } runs[] = { { "gl_MaxCullDistances", GL_MAX_CULL_DISTANCES, gl_max_cull_distances_value, 8 /*minimum required */,
 545                                    "GL_MAX_CULL_DISTANCES" },
 546                                  { "gl_MaxCombinedClipAndCullDistances", GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES,
 547                                    gl_max_combined_clip_and_cull_distances_value, 8 /*minimum required */,
 548                                    "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES" } };
 549
 550         static const glw::GLuint n_runs = sizeof(runs) / sizeof(runs[0]);
 551
 552         for (glw::GLuint n_run = 0; n_run < n_runs; ++n_run)
 553         {
 554                 _run& current_run = runs[n_run];
 555
 556                 static const struct _stage
 557                 {
 558                         bool use_cs;
 559                         bool use_fs;
 560                         bool use_gs;
 561                         bool use_tc;
 562                         bool use_te;
 563                         bool use_vs;
 564
 565                         const glw::GLchar* fs_input;
 566                         const glw::GLchar* gs_input;
 567                         const glw::GLchar* tc_input;
 568                         const glw::GLchar* te_input;
 569
 570                         const glw::GLchar* tf_output_name;
 571                         const glw::GLenum  tf_mode;
 572
 573                         glw::GLenum draw_call_mode;
 574                         glw::GLuint n_draw_call_vertices;
 575                 } stages[] = { /* CS only test */
 576                                            {
 577                                                    /* use_cs|use_fs|use_gs|use_tc|use_te|use_vs */
 578                                                    true, false, false, false, false, false,
 579
 580                                                    NULL,        /* fs_input             */
 581                                                    NULL,        /* gs_input             */
 582                                                    NULL,        /* tc_input             */
 583                                                    NULL,        /* te_input             */
 584                                                    NULL,        /* tf_output_name       */
 585                                                    GL_NONE, /* tf_mode              */
 586                                                    GL_NONE, /* draw_call_mode       */
 587                                                    0,           /* n_draw_call_vertices */
 588                                            },
 589                                            /* VS+GS+TC+TE+FS test */
 590                                            {
 591                                                    /* use_cs|use_fs|use_gs|use_tc|use_te|use_vs */
 592                                                    false, true, true, true, true, true,
 593
 594                                                    "out_gs",     /* fs_input             */
 595                                                    "out_te",     /* gs_input             */
 596                                                    "out_vs",     /* tc_input             */
 597                                                    "out_tc",     /* te_input             */
 598                                                    "out_gs",     /* tf_output_name       */
 599                                                    GL_TRIANGLES, /* tf_mode              */
 600                                                    GL_PATCHES,   /* draw_call_mode       */
 601                                                    3,                    /* n_draw_call_vertices */
 602                                            },
 603                                            /* VS+GS+FS test */
 604                                            {
 605                                                    /* use_cs|use_fs|use_gs|use_tc|use_te|use_vs */
 606                                                    false, true, true, false, false, true,
 607
 608                                                    "out_gs",     /* fs_input             */
 609                                                    "out_vs",     /* gs_input             */
 610                                                    NULL,                 /* tc_input             */
 611                                                    NULL,                 /* te_input             */
 612                                                    "out_gs",     /* tf_output_name       */
 613                                                    GL_TRIANGLES, /* tf_mode              */
 614                                                    GL_POINTS,   /* draw_call_mode       */
 615                                                    1,                    /* n_draw_call_vertices */
 616                                            },
 617                                            /* VS+TC+TE+FS test */
 618                                            {
 619                                                    /* use_cs|use_fs|use_gs|use_tc|use_te|use_vs */
 620                                                    false, true, false, true, true, true,
 621
 622                                                    "out_te",   /* fs_input             */
 623                                                    NULL,           /* gs_input             */
 624                                                    "out_vs",   /* tc_input             */
 625                                                    "out_tc",   /* te_input             */
 626                                                    "out_te",   /* tf_output_name       */
 627                                                    GL_POINTS,  /* tf_mode              */
 628                                                    GL_PATCHES, /* draw_call_mode       */
 629                                                    3               /* n_draw_call_vertices */
 630                                            },
 631                                            /* VS test */
 632                                            {
 633                                                    /* use_cs|use_fs|use_gs|use_tc|use_te|use_vs */
 634                                                    false, false, false, false, false, true,
 635
 636                                                    "out_vs",  /* fs_input             */
 637                                                    NULL,          /* gs_input             */
 638                                                    NULL,          /* tc_input             */
 639                                                    NULL,          /* te_input             */
 640                                                    "out_vs",  /* tf_output_name       */
 641                                                    GL_POINTS, /* tf_mode              */
 642                                                    GL_POINTS, /* draw_call_mode       */
 643                                                    1              /* n_draw_call_vertices */
 644                                            }
 645                 };
 646                 const glw::GLuint n_stages = sizeof(stages) / sizeof(stages[0]);
 647
 648                 /* Run through all test stages */
 649                 for (glw::GLuint n_stage = 0; n_stage < n_stages; ++n_stage)
 650                 {
 651                         /* Check for OpenGL feature support */
 652                         if (stages[n_stage].use_cs)
 653                         {
 654                                 if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 3)) &&
 655                                         !m_context.getContextInfo().isExtensionSupported("GL_ARB_compute_shader"))
 656                                 {
 657                                         continue; // no compute shader support
 658                                 }
 659                         }
 660                         if (stages[n_stage].use_tc || stages[n_stage].use_te)
 661                         {
 662                                 if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)) &&
 663                                         !m_context.getContextInfo().isExtensionSupported("GL_ARB_tessellation_shader"))
 664                                 {
 665                                         continue; // no tessellation shader support
 666                                 }
 667                         }
 668
 669                         /* Check that use of the GLSL built-in constant gl_MaxCullDistance in any
 670                          * shader stage (including compute shader) does not affect the shader
 671                          * compilation & program linking process.
 672                          */
 673                         static const glw::GLchar* cs_body_template =
 674                                 "#version 150\n"
 675                                 "\n"
 676                                 "#extension GL_ARB_compute_shader          : require\n"
 677                                 "#extension GL_ARB_cull_distance           : require\n"
 678                                 "#extension GL_ARB_shader_image_load_store : require\n"
 679                                 "\n"
 680                                 "layout(local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
 681                                 "\n"
 682                                 "layout(r32i) uniform writeonly iimage2D result;\n"
 683                                 "\n"
 684                                 "void main()\n"
 685                                 "{\n"
 686                                 "    imageStore(result, ivec2(0),ivec4(TOKEN) );\n"
 687                                 "}\n";
 688                         std::string cs_body = cs_body_template;
 689
 690                         static const glw::GLchar* fs_body_template = "#version 150\n"
 691                                                                                                                  "\n"
 692                                                                                                                  "#extension GL_ARB_cull_distance : require\n"
 693                                                                                                                  "\n"
 694                                                                                                                  "flat in  int INPUT_FS_NAME;\n"
 695                                                                                                                  "out int out_fs;\n"
 696                                                                                                                  "\n"
 697                                                                                                                  "void main()\n"
 698                                                                                                                  "{\n"
 699                                                                                                                  "    if (INPUT_FS_NAME == TOKEN)\n"
 700                                                                                                                  "    {\n"
 701                                                                                                                  "        out_fs = TOKEN;\n"
 702                                                                                                                  "    }\n"
 703                                                                                                                  "    else\n"
 704                                                                                                                  "    {\n"
 705                                                                                                                  "        out_fs = -1;\n"
 706                                                                                                                  "    }\n"
 707                                                                                                                  "}\n";
 708                         std::string fs_body = fs_body_template;
 709
 710                         static const glw::GLchar* gs_body_template =
 711                                 "#version 150\n"
 712                                 "\n"
 713                                 "#extension GL_ARB_cull_distance : require\n"
 714                                 "\n"
 715                                 "flat in  int INPUT_GS_NAME[];\n"
 716                                 "flat out int out_gs;\n"
 717                                 "\n"
 718                                 "layout(points)                           in;\n"
 719                                 "layout(triangle_strip, max_vertices = 4) out;\n"
 720                                 "\n"
 721                                 "void main()\n"
 722                                 "{\n"
 723                                 "    int result_value = (INPUT_GS_NAME[0] == TOKEN) ? TOKEN : -1;\n"
 724                                 "\n"
 725                                 /* Draw a full-screen quad */
 726                                 "    gl_Position = vec4(-1.0, 1.0, 0.0, 1.0);\n"
 727                                 "    out_gs      = result_value;\n"
 728                                 "    EmitVertex();\n"
 729                                 "\n"
 730                                 "    gl_Position = vec4(-1.0, -1.0, 0.0, 1.0);\n"
 731                                 "    out_gs      = result_value;\n"
 732                                 "    EmitVertex();\n"
 733                                 "\n"
 734                                 "    gl_Position = vec4(1.0, 1.0, 0.0, 1.0);\n"
 735                                 "    out_gs      = result_value;\n"
 736                                 "    EmitVertex();\n"
 737                                 "\n"
 738                                 "    gl_Position = vec4(1.0, -1.0, 0.0, 1.0);\n"
 739                                 "    out_gs      = result_value;\n"
 740                                 "    EmitVertex();\n"
 741                                 "    EndPrimitive();\n"
 742                                 "}\n";
 743                         std::string gs_body = gs_body_template;
 744
 745                         static const glw::GLchar* tc_body_template =
 746                                 "#version 400\n"
 747                                 "\n"
 748                                 "#extension GL_ARB_cull_distance : require\n"
 749                                 "\n"
 750                                 "layout(vertices = 1) out;\n"
 751                                 "\n"
 752                                 "flat in  int INPUT_TC_NAME[];\n"
 753                                 "flat out int out_tc       [];\n"
 754                                 "\n"
 755                                 "void main()\n"
 756                                 "{\n"
 757                                 "    int result_value = (INPUT_TC_NAME[0] == TOKEN) ? TOKEN : -1;\n"
 758                                 "\n"
 759                                 "    out_tc[gl_InvocationID]             = result_value;\n"
 760                                 "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 761                                 "    gl_TessLevelInner[0]                = 1.0;\n"
 762                                 "    gl_TessLevelInner[1]                = 1.0;\n"
 763                                 "    gl_TessLevelOuter[0]                = 1.0;\n"
 764                                 "    gl_TessLevelOuter[1]                = 1.0;\n"
 765                                 "    gl_TessLevelOuter[2]                = 1.0;\n"
 766                                 "    gl_TessLevelOuter[3]                = 1.0;\n"
 767                                 "}\n";
 768                         std::string tc_body = tc_body_template;
 769
 770                         static const glw::GLchar* te_body_template =
 771                                 "#version 400\n"
 772                                 "\n"
 773                                 "#extension GL_ARB_cull_distance : require\n"
 774                                 "\n"
 775                                 "flat in  int INPUT_TE_NAME[];\n"
 776                                 "flat out int out_te;\n"
 777                                 "\n"
 778                                 "layout(isolines, point_mode) in;\n"
 779                                 "\n"
 780                                 "void main()\n"
 781                                 "{\n"
 782                                 "    int result_value = (INPUT_TE_NAME[0] == TOKEN) ? TOKEN : 0;\n"
 783                                 "\n"
 784                                 "    out_te = result_value;\n"
 785                                 "\n"
 786                                 "    gl_Position = vec4(0.0, 0.0, 0.0, 1.);\n"
 787                                 "}\n";
 788                         std::string te_body = te_body_template;
 789
 790                         static const glw::GLchar* vs_body_template = "#version 150\n"
 791                                                                                                                  "\n"
 792                                                                                                                  "#extension GL_ARB_cull_distance : require\n"
 793                                                                                                                  "\n"
 794                                                                                                                  "flat out int out_vs;\n"
 795                                                                                                                  "\n"
 796                                                                                                                  "void main()\n"
 797                                                                                                                  "{\n"
 798                                                                                                                  "    gl_Position = vec4(0.0, 0.0, 0.0, 1.0);\n"
 799                                                                                                                  "    out_vs      = TOKEN;\n"
 800                                                                                                                  "}\n";
 801                         std::string vs_body = vs_body_template;
 802
 803                         const _stage& current_stage = stages[n_stage];
 804
 805                         /* Build shader bodies */
 806                         struct _shader_body
 807                         {
 808                                 std::string* body_ptr;
 809                                 glw::GLenum  gl_type;
 810                         } shader_bodies[] = { { &cs_body, GL_COMPUTE_SHADER },             { &fs_body, GL_FRAGMENT_SHADER },
 811                                                                   { &gs_body, GL_GEOMETRY_SHADER },                { &tc_body, GL_TESS_CONTROL_SHADER },
 812                                                                   { &te_body, GL_TESS_EVALUATION_SHADER }, { &vs_body, GL_VERTEX_SHADER } };
 813                         static const glw::GLchar* input_fs_token_string = "INPUT_FS_NAME";
 814                         static const glw::GLchar* input_gs_token_string = "INPUT_GS_NAME";
 815                         static const glw::GLchar* input_te_token_string = "INPUT_TE_NAME";
 816                         static const glw::GLchar* input_tc_token_string = "INPUT_TC_NAME";
 817                         static const glw::GLuint  n_shader_bodies               = sizeof(shader_bodies) / sizeof(shader_bodies[0]);
 818
 819                         std::size_t                               token_position = std::string::npos;
 820                         static const glw::GLchar* token_string   = "TOKEN";
 821
 822                         for (glw::GLuint n_shader_body = 0; n_shader_body < n_shader_bodies; ++n_shader_body)
 823                         {
 824                                 _shader_body& current_body = shader_bodies[n_shader_body];
 825
 826                                 /* Is this stage actually used? */
 827                                 if (((current_body.gl_type == GL_COMPUTE_SHADER) && (!current_stage.use_cs)) ||
 828                                         ((current_body.gl_type == GL_FRAGMENT_SHADER) && (!current_stage.use_fs)) ||
 829                                         ((current_body.gl_type == GL_TESS_CONTROL_SHADER) && (!current_stage.use_tc)) ||
 830                                         ((current_body.gl_type == GL_TESS_EVALUATION_SHADER) && (!current_stage.use_te)) ||
 831                                         ((current_body.gl_type == GL_VERTEX_SHADER) && (!current_stage.use_vs)))
 832                                 {
 833                                         /* Skip the iteration. */
 834                                         continue;
 835                                 }
 836
 837                                 /* Iterate over all token and replace them with stage-specific values */
 838                                 struct _token_value_pair
 839                                 {
 840                                         const glw::GLchar* token;
 841                                         const glw::GLchar* value;
 842                                 } token_value_pairs[] = {
 843                                         /* NOTE: The last entry is filled by the switch() block below */
 844                                         { token_string, current_run.essl_token_value },
 845                                         { NULL, NULL },
 846                                 };
 847
 848                                 const size_t n_token_value_pairs = sizeof(token_value_pairs) / sizeof(token_value_pairs[0]);
 849
 850                                 switch (current_body.gl_type)
 851                                 {
 852                                 case GL_COMPUTE_SHADER:
 853                                 case GL_VERTEX_SHADER:
 854                                         break;
 855
 856                                 case GL_FRAGMENT_SHADER:
 857                                 {
 858                                         token_value_pairs[1].token = input_fs_token_string;
 859                                         token_value_pairs[1].value = current_stage.fs_input;
 860
 861                                         break;
 862                                 }
 863
 864                                 case GL_GEOMETRY_SHADER:
 865                                 {
 866                                         token_value_pairs[1].token = input_gs_token_string;
 867                                         token_value_pairs[1].value = current_stage.gs_input;
 868
 869                                         break;
 870                                 }
 871
 872                                 case GL_TESS_CONTROL_SHADER:
 873                                 {
 874                                         token_value_pairs[1].token = input_tc_token_string;
 875                                         token_value_pairs[1].value = current_stage.tc_input;
 876
 877                                         break;
 878                                 }
 879
 880                                 case GL_TESS_EVALUATION_SHADER:
 881                                 {
 882                                         token_value_pairs[1].token = input_te_token_string;
 883                                         token_value_pairs[1].value = current_stage.te_input;
 884
 885                                         break;
 886                                 }
 887
 888                                 default:
 889                                         TCU_FAIL("Unrecognized shader body type");
 890                                 }
 891
 892                                 for (glw::GLuint n_pair = 0; n_pair < n_token_value_pairs; ++n_pair)
 893                                 {
 894                                         const _token_value_pair& current_pair = token_value_pairs[n_pair];
 895
 896                                         if (current_pair.token == NULL || current_pair.value == NULL)
 897                                         {
 898                                                 continue;
 899                                         }
 900
 901                                         while ((token_position = current_body.body_ptr->find(current_pair.token)) != std::string::npos)
 902                                         {
 903                                                 current_body.body_ptr->replace(token_position, strlen(current_pair.token), current_pair.value);
 904                                         }
 905                                 } /* for (all token+value pairs) */
 906                         }        /* for (all sader bodies) */
 907
 908                         /* Build the test program */
 909                         CullDistance::Utilities::buildProgram(
 910                                 gl, m_testCtx, current_stage.use_cs ? cs_body.c_str() : DE_NULL,
 911                                 current_stage.use_fs ? fs_body.c_str() : DE_NULL, current_stage.use_gs ? gs_body.c_str() : DE_NULL,
 912                                 current_stage.use_tc ? tc_body.c_str() : DE_NULL, current_stage.use_te ? te_body.c_str() : DE_NULL,
 913                                 current_stage.use_vs ? vs_body.c_str() : DE_NULL, (current_stage.tf_output_name != NULL) ? 1 : 0,
 914                                 (const glw::GLchar**)&current_stage.tf_output_name, &m_po_id);
 915
 916                         /* Bind the test program */
 917                         DE_ASSERT(m_po_id != 0);
 918
 919                         gl.useProgram(m_po_id);
 920                         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
 921
 922                         /* Execute the draw call. Transform Feed-back should be enabled for all iterations
 923                          * par the CS one, since we use a different tool to capture the result data in the
 924                          * latter case.
 925                          */
 926                         if (!current_stage.use_cs)
 927                         {
 928                                 gl.beginTransformFeedback(current_stage.tf_mode);
 929                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glBeginTransformFeedback() call failed.");
 930
 931                                 gl.drawArrays(current_stage.draw_call_mode, 0,   /* first */
 932                                                           current_stage.n_draw_call_vertices); /* count */
 933                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays() call failed.");
 934
 935                                 gl.endTransformFeedback();
 936                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glEndTransformFeedback() call failed.");
 937                         } /* if (uses_tf) */
 938                         else
 939                         {
 940                                 gl.dispatchCompute(1,  /* num_groups_x */
 941                                                                    1,  /* num_groups_y */
 942                                                                    1); /* num_groups_z */
 943                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glDispatchCompute() call failed.");
 944                         }
 945
 946                         /* Verify the result values */
 947                         if (!current_stage.use_cs)
 948                         {
 949                                 glw::GLint* result_data_ptr = DE_NULL;
 950
 951                                 /* Retrieve the data captured by Transform Feedback */
 952                                 result_data_ptr = (glw::GLint*)gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* offset */
 953                                                                                                                                  sizeof(unsigned int) * 1, GL_MAP_READ_BIT);
 954                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glMapBufferRange() call failed.");
 955
 956                                 if (*result_data_ptr != current_run.gl_value)
 957                                 {
 958                                         m_testCtx.getLog() << tcu::TestLog::Message << current_run.name << " value "
 959                                                                                                                                                                            "["
 960                                                                            << *result_data_ptr << "]"
 961                                                                                                                           " does not match the one reported by glGetIntegerv() "
 962                                                                                                                           "["
 963                                                                            << current_run.gl_value << "]" << tcu::TestLog::EndMessage;
 964
 965                                         TCU_FAIL("GL constant value does not match the ES SL equivalent");
 966                                 }
 967
 968                                 if (*result_data_ptr < current_run.min_value)
 969                                 {
 970                                         m_testCtx.getLog() << tcu::TestLog::Message << current_run.name << " value "
 971                                                                                                                                                                            "["
 972                                                                            << *result_data_ptr << "]"
 973                                                                                                                           " does not meet the minimum specification requirements "
 974                                                                                                                           "["
 975                                                                            << current_run.min_value << "]" << tcu::TestLog::EndMessage;
 976
 977                                         TCU_FAIL("GL constant value does not meet minimum specification requirements");
 978                                 }
 979
 980                                 gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
 981                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glUnmapBuffer() call failed.");
 982                         }
 983
 984                         for (glw::GLuint n_stage_internal = 0; n_stage_internal < 2; /* CS, FS write to separate textures */
 985                                  ++n_stage_internal)
 986                         {
 987                                 glw::GLuint to_id = (n_stage_internal == 0) ? m_cs_to_id : m_fbo_draw_to_id;
 988
 989                                 if (((n_stage_internal == 0) && (!current_stage.use_cs)) ||
 990                                         ((n_stage_internal == 1) && (!current_stage.use_fs)))
 991                                 {
 992                                         /* Skip the iteration */
 993                                         continue;
 994                                 }
 995
 996                                 /* Check the image data the test CS / FS should have written */
 997                                 glw::GLint result_value = 0;
 998
 999                                 gl.framebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, to_id, 0); /* level */
1000                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed.");
1001
1002                                 /* NOTE: We're using our custom read framebuffer here, so we'll be reading
1003                                  *       from the texture, that the writes have been issued to earlier. */
1004                                 gl.finish();
1005                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glMemoryBarrier() call failed.");
1006
1007                                 gl.readPixels(0, /* x */
1008                                                           0, /* y */
1009                                                           1, /* width */
1010                                                           1, /* height */
1011                                                           GL_RED_INTEGER, GL_INT, &result_value);
1012                                 GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed.");
1013
1014                                 if (result_value != current_run.gl_value)
1015                                 {
1016                                         m_testCtx.getLog() << tcu::TestLog::Message << current_run.name
1017                                                                            << " value accessible to the compute / fragment shader "
1018                                                                                   "["
1019                                                                            << result_value << "]"
1020                                                                                                                   " does not match the one reported by glGetIntegerv() "
1021                                                                                                                   "["
1022                                                                            << current_run.gl_value << "]" << tcu::TestLog::EndMessage;
1023
1024                                         TCU_FAIL("GL constant value does not match the ES SL equivalent");
1025                                 }
1026
1027                                 if (result_value < current_run.min_value)
1028                                 {
1029                                         m_testCtx.getLog() << tcu::TestLog::Message << current_run.name
1030                                                                            << " value accessible to the compute / fragment shader "
1031                                                                                   "["
1032                                                                            << result_value << "]"
1033                                                                                                                   " does not meet the minimum specification requirements "
1034                                                                                                                   "["
1035                                                                            << current_run.min_value << "]" << tcu::TestLog::EndMessage;
1036
1037                                         TCU_FAIL("GL constant value does not meet minimum specification requirements");
1038                                 }
1039                         }
1040
1041                         /* Clear the data buffer before we continue */
1042                         static const glw::GLubyte bo_clear_data[bo_size] = { 0 };
1043
1044                         gl.bufferSubData(GL_TRANSFORM_FEEDBACK_BUFFER, 0, /* offset */
1045                                                          bo_size, bo_clear_data);
1046                         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferSubData() call failed.");
1047
1048                         /* Clear the texture mip-map before we continue */
1049                         glw::GLint clear_values[4] = { 0, 0, 0, 0 };
1050
1051                         gl.clearBufferiv(GL_COLOR, 0, /* drawbuffer */
1052                                                          clear_values);
1053                         GLU_EXPECT_NO_ERROR(gl.getError(), "glClearBufferiv() call failed.");
1054
1055                         /* Release program before we move on to the next iteration */
1056                         if (m_po_id != 0)
1057                         {
1058                                 gl.deleteProgram(m_po_id);
1059
1060                                 m_po_id = 0;
1061                         }
1062                 } /* for (all stages) */
1063         }        /* for (both runs) */
1064
1065         /* All done */
1066         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1067
1068         return STOP;
1069 }
1070
1071 /** Constructor.
1072  *
1073  *  @param context Rendering context handle.
1074  **/
1075 CullDistance::FunctionalTest::FunctionalTest(deqp::Context& context)
1076         : TestCase(context, "functional", "Cull Distance Functional Test")
1077         , m_bo_data()
1078         , m_bo_id(0)
1079         , m_fbo_id(0)
1080         , m_po_id(0)
1081         , m_render_primitives(0)
1082         , m_render_vertices(0)
1083         , m_sub_grid_cell_size(0)
1084         , m_to_id(0)
1085         , m_vao_id(0)
1086         , m_to_height(512)
1087         , m_to_width(512)
1088         , m_to_pixel_data_cache()
1089 {
1090         /* Left blank on purpose */
1091 }
1092
1093 /** @brief Build OpenGL program for functional tests
1094  *
1095  *  @param [in]  clipdistances_array_size   use size of gl_ClipDistance array
1096  *  @param [in]  culldistances_array_size   use size of gl_CullDistance array
1097  *  @param [in]  dynamic_index_writes       use dunamic indexing for setting  the gl_ClipDistance and gl_CullDistance arrays
1098  *  @param [in]  primitive_mode             primitive_mode will be used for rendering
1099  *  @param [in]  redeclare_clipdistances    redeclare gl_ClipDistance
1100  *  @param [in]  redeclare_culldistances    redeclare gl_CullDistance
1101  *  @param [in]  use_core_functionality     use core OpenGL functionality
1102  *  @param [in]  use_gs                     use geometry shader
1103  *  @param [in]  use_ts                     use tessellation shader
1104  *  @param [in]  fetch_culldistance_from_fs fetch check sum of gl_ClipDistance and gl_CullDistance from fragment shader
1105  */
1106 void CullDistance::FunctionalTest::buildPO(glw::GLuint clipdistances_array_size, glw::GLuint culldistances_array_size,
1107                                                                                    bool dynamic_index_writes, _primitive_mode primitive_mode,
1108                                                                                    bool redeclare_clipdistances, bool redeclare_culldistances,
1109                                                                                    bool use_core_functionality, bool use_gs, bool use_ts,
1110                                                                                    bool fetch_culldistance_from_fs)
1111 {
1112         deinitPO();
1113
1114         /* Form the vertex shader */
1115         glw::GLuint clipdistances_input_size =
1116                 clipdistances_array_size > 0 ? clipdistances_array_size : 1; /* Avoid zero-sized array compilation error */
1117         glw::GLuint culldistances_input_size =
1118                 culldistances_array_size > 0 ? culldistances_array_size : 1; /* Avoid zero-sized array compilation error */
1119         static const glw::GLchar* dynamic_array_setters =
1120                 "\n"
1121                 "#if TEMPLATE_N_GL_CLIPDISTANCE_ENTRIES\n"
1122                 "        for (int n_clipdistance_entry = 0;\n"
1123                 "                 n_clipdistance_entry < TEMPLATE_N_GL_CLIPDISTANCE_ENTRIES;\n"
1124                 "               ++n_clipdistance_entry)\n"
1125                 "        {\n"
1126                 "            ASSIGN_CLIP_DISTANCE(n_clipdistance_entry);\n"
1127                 "        }\n"
1128                 "#endif"
1129                 "\n"
1130                 "#if TEMPLATE_N_GL_CULLDISTANCE_ENTRIES \n"
1131                 "        for (int n_culldistance_entry = 0;\n"
1132                 "                 n_culldistance_entry < TEMPLATE_N_GL_CULLDISTANCE_ENTRIES;\n"
1133                 "               ++n_culldistance_entry)\n"
1134                 "        {\n"
1135                 "            ASSIGN_CULL_DISTANCE(n_culldistance_entry);\n"
1136                 "        }\n"
1137                 "#endif\n";
1138
1139         static const glw::GLchar* core_functionality = "#version 450\n";
1140
1141         static const glw::GLchar* extention_functionality = "#version 440\n"
1142                                                                                                                 "\n"
1143                                                                                                                 "#extension GL_ARB_cull_distance : require\n"
1144                                                                                                                 "\n"
1145                                                                                                                 "#ifndef GL_ARB_cull_distance\n"
1146                                                                                                                 "    #error GL_ARB_cull_distance is undefined\n"
1147                                                                                                                 "#endif\n";
1148
1149         static const glw::GLchar* fetch_function = "highp float fetch()\n"
1150                                                                                            "{\n"
1151                                                                                            "    highp float sum = 0.0;\n"
1152                                                                                            "\n"
1153                                                                                            "TEMPLATE_SUM_SETTER"
1154                                                                                            "\n"
1155                                                                                            "    return sum / TEMPLATE_SUM_DIVIDER;\n"
1156                                                                                            "}\n"
1157                                                                                            "\n"
1158                                                                                            "#define ASSIGN_RETURN_VALUE fetch()";
1159
1160         static const glw::GLchar* fs_template = "TEMPLATE_HEADER_DECLARATION\n"
1161                                                                                         "\n"
1162                                                                                         "TEMPLATE_REDECLARE_CLIPDISTANCE\n"
1163                                                                                         "TEMPLATE_REDECLARE_CULLDISTANCE\n"
1164                                                                                         "\n"
1165                                                                                         "TEMPLATE_ASSIGN_RETURN_VALUE\n"
1166                                                                                         "\n"
1167                                                                                         "out vec4 out_fs;\n"
1168                                                                                         "\n"
1169                                                                                         "/* Fragment shader main function */\n"
1170                                                                                         "void main()\n"
1171                                                                                         "{\n"
1172                                                                                         "    out_fs = vec4(ASSIGN_RETURN_VALUE, 1.0, 1.0, 1.0);\n"
1173                                                                                         "}\n";
1174
1175         static const glw::GLchar* gs_template = "TEMPLATE_HEADER_DECLARATION\n"
1176                                                                                         "\n"
1177                                                                                         "TEMPLATE_LAYOUT_IN\n"
1178                                                                                         "TEMPLATE_LAYOUT_OUT\n"
1179                                                                                         "\n"
1180                                                                                         "TEMPLATE_REDECLARE_CLIPDISTANCE\n"
1181                                                                                         "TEMPLATE_REDECLARE_CULLDISTANCE\n"
1182                                                                                         "\n"
1183                                                                                         "#define ASSIGN_CLIP_DISTANCE(IDX) TEMPLATE_ASSIGN_CLIP_DISTANCE\n"
1184                                                                                         "#define ASSIGN_CULL_DISTANCE(IDX) TEMPLATE_ASSIGN_CULL_DISTANCE\n"
1185                                                                                         "\n"
1186                                                                                         "/* Geometry shader (passthrough) main function */\n"
1187                                                                                         "void main()\n"
1188                                                                                         "{\n"
1189                                                                                         "    for (int n_vertex_index = 0;\n"
1190                                                                                         "             n_vertex_index < gl_in.length();\n"
1191                                                                                         "             n_vertex_index ++)\n"
1192                                                                                         "    {\n"
1193                                                                                         "        gl_Position = gl_in[n_vertex_index].gl_Position;\n"
1194                                                                                         "\n"
1195                                                                                         "        TEMPLATE_ARRAY_SETTERS\n"
1196                                                                                         "\n"
1197                                                                                         "        EmitVertex();\n"
1198                                                                                         "    }\n"
1199                                                                                         "\n"
1200                                                                                         "    EndPrimitive();\n"
1201                                                                                         "}\n";
1202
1203         static const glw::GLchar* tc_template =
1204                 "TEMPLATE_HEADER_DECLARATION\n"
1205                 "\n"
1206                 "TEMPLATE_LAYOUT_OUT\n"
1207                 "\n"
1208                 "out gl_PerVertex {\n"
1209                 "TEMPLATE_REDECLARE_CLIPDISTANCE\n"
1210                 "TEMPLATE_REDECLARE_CULLDISTANCE\n"
1211                 "vec4 gl_Position;\n"
1212                 "} gl_out[];\n"
1213                 "\n"
1214                 "#define ASSIGN_CLIP_DISTANCE(IDX) TEMPLATE_ASSIGN_CLIP_DISTANCE\n"
1215                 "#define ASSIGN_CULL_DISTANCE(IDX) TEMPLATE_ASSIGN_CULL_DISTANCE\n"
1216                 "\n"
1217                 "/* Tesselation control shader main function */\n"
1218                 "void main()\n"
1219                 "{\n"
1220                 "    gl_TessLevelInner[0] = 1.0;\n"
1221                 "    gl_TessLevelInner[1] = 1.0;\n"
1222                 "    gl_TessLevelOuter[0] = 1.0;\n"
1223                 "    gl_TessLevelOuter[1] = 1.0;\n"
1224                 "    gl_TessLevelOuter[2] = 1.0;\n"
1225                 "    gl_TessLevelOuter[3] = 1.0;\n"
1226                 "    /* Clipdistance and culldistance array setters */\n"
1227                 "    {\n"
1228                 "        TEMPLATE_ARRAY_SETTERS\n"
1229                 "    }\n"
1230                 "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
1231                 "}\n";
1232
1233         static const glw::GLchar* te_template = "TEMPLATE_HEADER_DECLARATION\n"
1234                                                                                         "\n"
1235                                                                                         "TEMPLATE_LAYOUT_IN\n"
1236                                                                                         "\n"
1237                                                                                         "in gl_PerVertex {\n"
1238                                                                                         "TEMPLATE_REDECLARE_IN_CLIPDISTANCE\n"
1239                                                                                         "TEMPLATE_REDECLARE_IN_CULLDISTANCE\n"
1240                                                                                         "vec4 gl_Position;\n"
1241                                                                                         "} gl_in[];\n"
1242                                                                                         "\n"
1243                                                                                         "TEMPLATE_REDECLARE_CLIPDISTANCE\n"
1244                                                                                         "TEMPLATE_REDECLARE_CULLDISTANCE\n"
1245                                                                                         "\n"
1246                                                                                         "#define ASSIGN_CLIP_DISTANCE(IDX) TEMPLATE_ASSIGN_CLIP_DISTANCE\n"
1247                                                                                         "#define ASSIGN_CULL_DISTANCE(IDX) TEMPLATE_ASSIGN_CULL_DISTANCE\n"
1248                                                                                         "\n"
1249                                                                                         "/* Tesselation evaluation shader main function */\n"
1250                                                                                         "void main()\n"
1251                                                                                         "{\n"
1252                                                                                         "    /* Clipdistance and culldistance array setters */\n"
1253                                                                                         "    {\n"
1254                                                                                         "        TEMPLATE_ARRAY_SETTERS\n"
1255                                                                                         "    }\n"
1256                                                                                         "    gl_Position = TEMPLATE_OUT_FORMULA;\n"
1257                                                                                         "}\n";
1258
1259         static const glw::GLchar* vs_template =
1260                 "TEMPLATE_HEADER_DECLARATION\n"
1261                 "\n"
1262                 "in float clipdistance_data[TEMPLATE_CLIPDISTANCE_INPUT_SIZE];\n"
1263                 "in float culldistance_data[TEMPLATE_CULLDISTANCE_INPUT_SIZE];\n"
1264                 "in vec2  position;\n"
1265                 "\n"
1266                 "TEMPLATE_REDECLARE_CLIPDISTANCE\n"
1267                 "TEMPLATE_REDECLARE_CULLDISTANCE\n"
1268                 "\n"
1269                 "#define ASSIGN_CLIP_DISTANCE(IDX) TEMPLATE_ASSIGN_CLIP_DISTANCE\n"
1270                 "#define ASSIGN_CULL_DISTANCE(IDX) TEMPLATE_ASSIGN_CULL_DISTANCE\n"
1271                 "\n"
1272                 "/* Vertex shader main function */\n"
1273                 "void main()\n"
1274                 "{\n"
1275                 "    /* Clipdistance and culldistance array setters */\n"
1276                 "    {\n"
1277                 "        TEMPLATE_ARRAY_SETTERS\n"
1278                 "    }\n"
1279                 "    gl_Position = vec4(2.0 * position.x - 1.0, 2.0 * position.y - 1.0, 0.0, 1.0);\n"
1280                 "}\n";
1281
1282         std::string* shader_body_string_fs       = DE_NULL;
1283         std::string* shader_body_string_gs       = DE_NULL;
1284         std::string* shader_body_string_tc       = DE_NULL;
1285         std::string* shader_body_string_te       = DE_NULL;
1286         std::string* shader_body_string_vs       = DE_NULL;
1287         std::string  shader_header_declaration = use_core_functionality ? core_functionality : extention_functionality;
1288
1289         struct _shaders_configuration
1290         {
1291                 glw::GLenum                type;
1292                 const glw::GLchar* shader_template;
1293                 std::string                body;
1294                 const bool                 use;
1295         } shaders_configuration[] = { {
1296                                                                           GL_FRAGMENT_SHADER, fs_template, std::string(), true,
1297                                                                   },
1298                                                                   {
1299                                                                           GL_GEOMETRY_SHADER, gs_template, std::string(), use_gs,
1300                                                                   },
1301                                                                   {
1302                                                                           GL_TESS_CONTROL_SHADER, tc_template, std::string(), use_ts,
1303                                                                   },
1304                                                                   {
1305                                                                           GL_TESS_EVALUATION_SHADER, te_template, std::string(), use_ts,
1306                                                                   },
1307                                                                   {
1308                                                                           GL_VERTEX_SHADER, vs_template, std::string(), true,
1309                                                                   } };
1310
1311         const glw::GLuint n_shaders_configuration = sizeof(shaders_configuration) / sizeof(shaders_configuration[0]);
1312
1313         /* Construct shader bodies out of templates */
1314         for (glw::GLuint n_shader_index = 0; n_shader_index < n_shaders_configuration; n_shader_index++)
1315         {
1316                 if (shaders_configuration[n_shader_index].use)
1317                 {
1318                         std::string  array_setters;
1319                         std::string  clipdistance_array_declaration;
1320                         std::string  culldistance_array_declaration;
1321                         std::string  clipdistance_in_array_declaration;
1322                         std::string  culldistance_in_array_declaration;
1323                         std::string& shader_source = shaders_configuration[n_shader_index].body;
1324
1325                         /* Copy template into shader body source */
1326                         shader_source = shaders_configuration[n_shader_index].shader_template;
1327
1328                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_HEADER_DECLARATION"),
1329                                                                                                 shader_header_declaration);
1330
1331                         /* Shader-specific actions */
1332                         switch (shaders_configuration[n_shader_index].type)
1333                         {
1334                         case GL_FRAGMENT_SHADER:
1335                         {
1336                                 shader_body_string_fs = &shaders_configuration[n_shader_index].body;
1337
1338                                 if (fetch_culldistance_from_fs)
1339                                 {
1340                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_ASSIGN_RETURN_VALUE"),
1341                                                                                                                 std::string(fetch_function));
1342
1343                                         std::string fetch_sum_setters = "";
1344                                         for (glw::GLuint i = 0; i < clipdistances_array_size; ++i)
1345                                         {
1346                                                 fetch_sum_setters.append("    sum += abs(gl_ClipDistance[");
1347                                                 fetch_sum_setters.append(CullDistance::Utilities::intToString(i));
1348                                                 fetch_sum_setters.append("]) * ");
1349                                                 fetch_sum_setters.append(CullDistance::Utilities::intToString(i + 1));
1350                                                 fetch_sum_setters.append(".0;\n");
1351                                         }
1352
1353                                         fetch_sum_setters.append("\n");
1354
1355                                         for (glw::GLuint i = 0; i < culldistances_array_size; ++i)
1356                                         {
1357                                                 fetch_sum_setters.append("    sum += abs(gl_CullDistance[");
1358                                                 fetch_sum_setters.append(CullDistance::Utilities::intToString(i));
1359                                                 fetch_sum_setters.append("]) * ");
1360                                                 fetch_sum_setters.append(
1361                                                         CullDistance::Utilities::intToString(i + 1 + clipdistances_array_size));
1362                                                 fetch_sum_setters.append(".0;\n");
1363                                         }
1364
1365                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_SUM_SETTER"),
1366                                                                                                                 std::string(fetch_sum_setters));
1367                                         CullDistance::Utilities::replaceAll(
1368                                                 shader_source, std::string("TEMPLATE_SUM_DIVIDER"),
1369                                                 std::string(CullDistance::Utilities::intToString(
1370                                                                                 (clipdistances_array_size + culldistances_array_size) *
1371                                                                                 ((clipdistances_array_size + culldistances_array_size + 1))))
1372                                                         .append(".0"));
1373                                 }
1374                                 else
1375                                 {
1376                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_ASSIGN_RETURN_VALUE"),
1377                                                                                                                 std::string("#define ASSIGN_RETURN_VALUE 1.0"));
1378                                 }
1379
1380                                 break;
1381                         }
1382
1383                         case GL_GEOMETRY_SHADER:
1384                         {
1385                                 shader_body_string_gs = &shaders_configuration[n_shader_index].body;
1386
1387                                 CullDistance::Utilities::replaceAll(
1388                                         shader_source, std::string("TEMPLATE_ASSIGN_CLIP_DISTANCE"),
1389                                         std::string("gl_ClipDistance[IDX] = gl_in[n_vertex_index].gl_ClipDistance[IDX]"));
1390                                 CullDistance::Utilities::replaceAll(
1391                                         shader_source, std::string("TEMPLATE_ASSIGN_CULL_DISTANCE"),
1392                                         std::string("gl_CullDistance[IDX] = gl_in[n_vertex_index].gl_CullDistance[IDX]"));
1393
1394                                 switch (primitive_mode)
1395                                 {
1396                                 case PRIMITIVE_MODE_LINES:
1397                                 {
1398                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_IN"),
1399                                                                                                                 std::string("layout(lines)                        in;"));
1400                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_OUT"),
1401                                                                                                                 std::string("layout(line_strip, max_vertices = 2) out;"));
1402
1403                                         break;
1404                                 }
1405                                 case PRIMITIVE_MODE_POINTS:
1406                                 {
1407                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_IN"),
1408                                                                                                                 std::string("layout(points)                   in;"));
1409                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_OUT"),
1410                                                                                                                 std::string("layout(points, max_vertices = 1) out;"));
1411
1412                                         break;
1413                                 }
1414                                 case PRIMITIVE_MODE_TRIANGLES:
1415                                 {
1416                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_IN"),
1417                                                                                                                 std::string("layout(triangles)                        in;"));
1418                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_OUT"),
1419                                                                                                                 std::string("layout(triangle_strip, max_vertices = 3) out;"));
1420
1421                                         break;
1422                                 }
1423                                 default:
1424                                         TCU_FAIL("Unknown primitive mode");
1425                                 }
1426
1427                                 break;
1428                         }
1429
1430                         case GL_TESS_CONTROL_SHADER:
1431                         {
1432                                 shader_body_string_tc = &shaders_configuration[n_shader_index].body;
1433
1434                                 CullDistance::Utilities::replaceAll(
1435                                         shader_source, std::string("TEMPLATE_ASSIGN_CLIP_DISTANCE"),
1436                                         std::string(
1437                                                 "gl_out[gl_InvocationID].gl_ClipDistance[IDX] = gl_in[gl_InvocationID].gl_ClipDistance[IDX]"));
1438                                 CullDistance::Utilities::replaceAll(
1439                                         shader_source, std::string("TEMPLATE_ASSIGN_CULL_DISTANCE"),
1440                                         std::string(
1441                                                 "gl_out[gl_InvocationID].gl_CullDistance[IDX] = gl_in[gl_InvocationID].gl_CullDistance[IDX]"));
1442
1443                                 switch (primitive_mode)
1444                                 {
1445                                 case PRIMITIVE_MODE_LINES:
1446                                 {
1447                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_OUT"),
1448                                                                                                                 std::string("layout(vertices = 2) out;"));
1449
1450                                         break;
1451                                 }
1452                                 case PRIMITIVE_MODE_POINTS:
1453                                 {
1454                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_OUT"),
1455                                                                                                                 std::string("layout(vertices = 1) out;"));
1456
1457                                         break;
1458                                 }
1459                                 case PRIMITIVE_MODE_TRIANGLES:
1460                                 {
1461                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_OUT"),
1462                                                                                                                 std::string("layout(vertices = 3) out;"));
1463
1464                                         break;
1465                                 }
1466                                 default:
1467                                         TCU_FAIL("Unknown primitive mode");
1468                                 }
1469
1470                                 break;
1471                         }
1472
1473                         case GL_TESS_EVALUATION_SHADER:
1474                         {
1475                                 shader_body_string_te = &shaders_configuration[n_shader_index].body;
1476
1477                                 switch (primitive_mode)
1478                                 {
1479                                 case PRIMITIVE_MODE_LINES:
1480                                 {
1481                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_IN"),
1482                                                                                                                 std::string("layout(isolines) in;"));
1483                                         CullDistance::Utilities::replaceAll(
1484                                                 shader_source, std::string("TEMPLATE_OUT_FORMULA"),
1485                                                 std::string("mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x)"));
1486                                         CullDistance::Utilities::replaceAll(
1487                                                 shader_source, std::string("TEMPLATE_ASSIGN_CLIP_DISTANCE"),
1488                                                 std::string("gl_ClipDistance[IDX] = mix(gl_in[0].gl_ClipDistance[IDX], "
1489                                                                         "gl_in[1].gl_ClipDistance[IDX], gl_TessCoord.x)"));
1490                                         CullDistance::Utilities::replaceAll(
1491                                                 shader_source, std::string("TEMPLATE_ASSIGN_CULL_DISTANCE"),
1492                                                 std::string("gl_CullDistance[IDX] = mix(gl_in[0].gl_CullDistance[IDX], "
1493                                                                         "gl_in[1].gl_CullDistance[IDX], gl_TessCoord.x)"));
1494
1495                                         break;
1496                                 }
1497                                 case PRIMITIVE_MODE_POINTS:
1498                                 {
1499                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_IN"),
1500                                                                                                                 std::string("layout(isolines, point_mode) in;"));
1501                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_OUT_FORMULA"),
1502                                                                                                                 std::string("gl_in[0].gl_Position"));
1503                                         CullDistance::Utilities::replaceAll(
1504                                                 shader_source, std::string("TEMPLATE_ASSIGN_CLIP_DISTANCE"),
1505                                                 std::string("gl_ClipDistance[IDX] = gl_in[0].gl_ClipDistance[IDX]"));
1506                                         CullDistance::Utilities::replaceAll(
1507                                                 shader_source, std::string("TEMPLATE_ASSIGN_CULL_DISTANCE"),
1508                                                 std::string("gl_CullDistance[IDX] = gl_in[0].gl_CullDistance[IDX]"));
1509
1510                                         break;
1511                                 }
1512                                 case PRIMITIVE_MODE_TRIANGLES:
1513                                 {
1514                                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_LAYOUT_IN"),
1515                                                                                                                 std::string("layout(triangles) in;"));
1516                                         CullDistance::Utilities::replaceAll(
1517                                                 shader_source, std::string("TEMPLATE_OUT_FORMULA"),
1518                                                 std::string("vec4(mat3(gl_in[0].gl_Position.xyz, gl_in[1].gl_Position.xyz, "
1519                                                                         "gl_in[2].gl_Position.xyz) * gl_TessCoord, 1.0)"));
1520                                         CullDistance::Utilities::replaceAll(
1521                                                 shader_source, std::string("TEMPLATE_ASSIGN_CLIP_DISTANCE"),
1522                                                 std::string("gl_ClipDistance[IDX] = dot(vec3(gl_in[0].gl_ClipDistance[IDX], "
1523                                                                         "gl_in[1].gl_ClipDistance[IDX], gl_in[2].gl_ClipDistance[IDX]), gl_TessCoord)"));
1524                                         CullDistance::Utilities::replaceAll(
1525                                                 shader_source, std::string("TEMPLATE_ASSIGN_CULL_DISTANCE"),
1526                                                 std::string("gl_CullDistance[IDX] = dot(vec3(gl_in[0].gl_CullDistance[IDX], "
1527                                                                         "gl_in[1].gl_CullDistance[IDX], gl_in[2].gl_CullDistance[IDX]), gl_TessCoord)"));
1528
1529                                         break;
1530                                 }
1531                                 default:
1532                                         TCU_FAIL("Unknown primitive mode");
1533                                 }
1534
1535                                 break;
1536                         }
1537
1538                         case GL_VERTEX_SHADER:
1539                         {
1540                                 shader_body_string_vs = &shaders_configuration[n_shader_index].body;
1541
1542                                 /* Specify input data size for clipdistances data */
1543                                 CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_CLIPDISTANCE_INPUT_SIZE"),
1544                                                                                                         CullDistance::Utilities::intToString(clipdistances_input_size));
1545
1546                                 /* Specify input data size for culldistances data */
1547                                 CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_CULLDISTANCE_INPUT_SIZE"),
1548                                                                                                         CullDistance::Utilities::intToString(culldistances_input_size));
1549
1550                                 CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_ASSIGN_CLIP_DISTANCE"),
1551                                                                                                         std::string("gl_ClipDistance[IDX] = clipdistance_data[IDX]"));
1552                                 CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_ASSIGN_CULL_DISTANCE"),
1553                                                                                                         std::string("gl_CullDistance[IDX] = culldistance_data[IDX]"));
1554
1555                                 break;
1556                         }
1557
1558                         default:
1559                                 TCU_FAIL("Unknown shader type");
1560                         }
1561
1562                         /* Adjust clipdistances declaration */
1563                         if (redeclare_clipdistances && clipdistances_array_size > 0)
1564                         {
1565                                 if (shaders_configuration[n_shader_index].type == GL_FRAGMENT_SHADER)
1566                                 {
1567                                         if (fetch_culldistance_from_fs)
1568                                         {
1569                                                 clipdistance_array_declaration =
1570                                                         std::string("in float gl_ClipDistance[") +
1571                                                         CullDistance::Utilities::intToString(clipdistances_array_size) + std::string("];");
1572                                         }
1573                                 }
1574                                 else if (shaders_configuration[n_shader_index].type == GL_TESS_CONTROL_SHADER)
1575                                 {
1576                                         clipdistance_array_declaration = std::string("float gl_ClipDistance[") +
1577                                                                                                          CullDistance::Utilities::intToString(clipdistances_array_size) +
1578                                                                                                          std::string("];");
1579                                 }
1580                                 else
1581                                 {
1582                                         clipdistance_array_declaration = std::string("out float gl_ClipDistance[") +
1583                                                                                                          CullDistance::Utilities::intToString(clipdistances_array_size) +
1584                                                                                                          std::string("];");
1585                                         clipdistance_in_array_declaration = std::string("in float gl_ClipDistance[") +
1586                                                                                                                 CullDistance::Utilities::intToString(clipdistances_array_size) +
1587                                                                                                                 std::string("];");
1588                                 }
1589                         }
1590                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_REDECLARE_CLIPDISTANCE"),
1591                                                                                                 clipdistance_array_declaration);
1592                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_REDECLARE_IN_CLIPDISTANCE"),
1593                                                                                                 clipdistance_in_array_declaration);
1594
1595                         /* Adjust culldistances declaration */
1596                         if (redeclare_culldistances && culldistances_array_size > 0)
1597                         {
1598                                 if (shaders_configuration[n_shader_index].type == GL_FRAGMENT_SHADER)
1599                                 {
1600                                         if (fetch_culldistance_from_fs)
1601                                         {
1602                                                 culldistance_array_declaration =
1603                                                         std::string("in float gl_CullDistance[") +
1604                                                         CullDistance::Utilities::intToString(culldistances_array_size) + std::string("];");
1605                                         }
1606                                 }
1607                                 else if (shaders_configuration[n_shader_index].type == GL_TESS_CONTROL_SHADER)
1608                                 {
1609                                         culldistance_array_declaration = std::string("float gl_CullDistance[") +
1610                                                                                                          CullDistance::Utilities::intToString(culldistances_array_size) +
1611                                                                                                          std::string("];");
1612                                 }
1613                                 else
1614                                 {
1615                                         culldistance_array_declaration = std::string("out float gl_CullDistance[") +
1616                                                                                                          CullDistance::Utilities::intToString(culldistances_array_size) +
1617                                                                                                          std::string("];");
1618                                         culldistance_in_array_declaration = std::string("in float gl_CullDistance[") +
1619                                                                                                                 CullDistance::Utilities::intToString(culldistances_array_size) +
1620                                                                                                                 std::string("];");
1621                                 }
1622                         }
1623                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_REDECLARE_CULLDISTANCE"),
1624                                                                                                 culldistance_array_declaration);
1625                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_REDECLARE_IN_CULLDISTANCE"),
1626                                                                                                 culldistance_in_array_declaration);
1627
1628                         /* Adjust clip/cull distances setters */
1629                         if (dynamic_index_writes)
1630                         {
1631                                 array_setters = dynamic_array_setters;
1632
1633                                 CullDistance::Utilities::replaceAll(array_setters, std::string("TEMPLATE_N_GL_CLIPDISTANCE_ENTRIES"),
1634                                                                                                         CullDistance::Utilities::intToString(clipdistances_array_size));
1635                                 CullDistance::Utilities::replaceAll(array_setters, std::string("TEMPLATE_N_GL_CULLDISTANCE_ENTRIES"),
1636                                                                                                         CullDistance::Utilities::intToString(culldistances_array_size));
1637                         }
1638                         else
1639                         {
1640                                 std::stringstream static_array_setters_sstream;
1641
1642                                 static_array_setters_sstream << "\n";
1643
1644                                 for (glw::GLuint clipdistances_array_entry = 0; clipdistances_array_entry < clipdistances_array_size;
1645                                          ++clipdistances_array_entry)
1646                                 {
1647                                         static_array_setters_sstream << "        ASSIGN_CLIP_DISTANCE(" << clipdistances_array_entry
1648                                                                                                  << ");\n";
1649                                 }
1650
1651                                 static_array_setters_sstream << "\n";
1652
1653                                 for (glw::GLuint culldistances_array_entry = 0; culldistances_array_entry < culldistances_array_size;
1654                                          ++culldistances_array_entry)
1655                                 {
1656                                         static_array_setters_sstream << "        ASSIGN_CULL_DISTANCE(" << culldistances_array_entry
1657                                                                                                  << ");\n";
1658                                 }
1659
1660                                 array_setters = static_array_setters_sstream.str();
1661                         }
1662
1663                         CullDistance::Utilities::replaceAll(shader_source, std::string("TEMPLATE_ARRAY_SETTERS"), array_setters);
1664                 }
1665         }
1666
1667         /* Build the geometry shader */
1668         CullDistance::Utilities::buildProgram(
1669                 m_context.getRenderContext().getFunctions(), m_testCtx, DE_NULL, /* Compute shader                    */
1670                 shader_body_string_fs != DE_NULL ? shader_body_string_fs->c_str() :
1671                                                                                    DE_NULL, /* Fragment shader                   */
1672                 shader_body_string_gs != DE_NULL ? shader_body_string_gs->c_str() :
1673                                                                                    DE_NULL, /* Geometry shader                   */
1674                 shader_body_string_tc != DE_NULL ? shader_body_string_tc->c_str() :
1675                                                                                    DE_NULL, /* Tesselation control shader        */
1676                 shader_body_string_te != DE_NULL ? shader_body_string_te->c_str() :
1677                                                                                    DE_NULL, /* Tesselation evaluation shader     */
1678                 shader_body_string_vs != DE_NULL ? shader_body_string_vs->c_str() :
1679                                                                                    DE_NULL, /* Vertex shader                     */
1680                 0,                                                                                      /* Transform feedback varyings count */
1681                 DE_NULL,                                                                        /* Transform feedback varyings       */
1682                 &m_po_id                                                                        /* Program object id                 */
1683                 );
1684 }
1685
1686 /** Generates primitive data required to test a case with specified
1687  *  gl_ClipDistance and glCullDistance array sizes for specified
1688  *  primitive mode. Generated primitive data is stored in m_bo_data
1689  *  as well uploaded into buffer specified in m_bo_id buffer.
1690  *  Also the procedure binds vertex attribute locations to
1691  *  program object m_po_id.
1692  *
1693  *  @param clipdistances_array_size gl_ClipDistance array size. Can be 0.
1694  *  @param culldistances_array_size gl_CullDistance array size. Can be 0.
1695  *  @param _primitive_mode          Primitives to be generated. Can be:
1696  *                                  PRIMITIVE_MODE_POINTS,
1697  *                                  PRIMITIVE_MODE_LINES,
1698  *                                  PRIMITIVE_MODE_TRIANGLES.
1699  */
1700 void CullDistance::FunctionalTest::configureVAO(glw::GLuint clipdistances_array_size,
1701                                                                                                 glw::GLuint culldistances_array_size, _primitive_mode primitive_mode)
1702 {
1703         /* Detailed test description.
1704          *
1705          * configureVAO() generates primitives layouted in grid. Primitve
1706          * consists of up to 3 vertices and each vertex is accompanied by:
1707          * - array of clipdistances (clipdistances_array_size floats);
1708          * - array of culldistances (culldistances_array_size floats);
1709          * - rendering position coordinates (x and y);
1710          * - check position coordinates (x and y).
1711          *
1712          * The grid has following layout:
1713          *
1714          *     Grid                       |         gl_CullDistance[x]         |
1715          *                                |  0 .. culldistances_array_size - 1 |
1716          *                                |  0th  |  1st  |  2nd  | .......... |
1717          *     ---------------------------+-------+-------+-------+------------+
1718          *     0th  gl_ClipDistance       |Subgrid|Subgrid|Subgrid| .......... |
1719          *     1st  gl_ClipDistance       |Subgrid|Subgrid|Subgrid| .......... |
1720          *     ...                        |  ...  |  ...  |  ...  | .......... |
1721          *     y-th gl_ClipDistance       |Subgrid|Subgrid|Subgrid| .......... |
1722          *     ...                        |  ...  |  ...  |  ...  | .......... |
1723          *     clipdistances_array_size-1 |Subgrid|Subgrid|Subgrid| .......... |
1724          *
1725          * Each grid cell contains subgrid of 3*3 items in size with following
1726          * structure:
1727          *
1728          *     Subgrid        |        x-th gl_CullDistance test           |
1729          *                    |                                            |
1730          *     y-th           | all vertices | 0th vertex   | all vertices |
1731          *     gl_ClipDistance| in primitive | in primitive | in primitive |
1732          *     tests          | dist[x] > 0  | dist[x] < 0  | dist[x] < 0  |
1733          *     ---------------+--------------+--------------+--------------+
1734          *        all vertices| primitive #0 | primitive #1 | primitive #2 |
1735          *        in primitive|              |              |              |
1736          *        dist[y] > 0 |   visible    |   visible    |    culled    |
1737          *     ---------------+--------------+--------------+--------------+
1738          *        0th vertex  | primitive #3 | primitive #4 | primitive #5 |
1739          *        in primitive|  0th vertex  |  0th vertex  |              |
1740          *        dist[y] < 0 |   clipped    |   clipped    |    culled    |
1741          *     ---------------+--------------+--------------+--------------+
1742          *        all vertices| primitive #6 | primitive #7 | primitive #8 |
1743          *        in primitive|              |              |              |
1744          *        dist[y] < 0 |   clipped    |   clipped    |    culled    |
1745          *     ---------------+--------------+--------------+--------------+
1746          *
1747          * Expected rendering result is specified in cell bottom.
1748          * It can be one of the following:
1749          * - "visible" means the primitive is not affected neither by gl_CullDistance
1750          *             nor by gl_ClipDistance and rendered as a whole;
1751          * - "clipped" for the vertex means the vertex is not rendered, while other
1752          *             primitive vertices and some filling fragments are rendered;
1753          * - "clipped" for primitive means none of primitive vertices and fragments
1754          *             are rendered and thus primitive is not rendered and is invisible;
1755          * - "culled"  means, that neither primitive vertices, nor primitive filling
1756          *             fragments are rendered (primitive is invisible).
1757          *
1758          * All subgrid items contain same primitive rendered. Depending on
1759          * test case running it would be either triangle, or line, or point:
1760          *
1761          *     triangle    line        point
1762          *     8x8 box     8x8 box     3x3 box
1763          *     ........    ........    ...
1764          *     .0----2.    .0......    .0.
1765          *     ..\@@@|.    ..\.....    ...
1766          *     ...\@@|.    ...\....
1767          *     ....\@|.    ....\...
1768          *     .....\|.    .....\..
1769          *     ......1.    ......1.
1770          *     ........    ........
1771          *
1772          *     where 0 - is a 0th vertex primitive
1773          *           1 - is a 1st vertex primitive
1774          *           2 - is a 2nd vertex primitive
1775          *
1776          * The culldistances_array_size can be 0. In that case, grid height
1777          * is assumed equal to 1, but 0 glCullDistances is specified.
1778          * Similar handled clipdistances_array_size.
1779          *
1780          * The data generated is used and checked in executeRenderTest().
1781          * After rendering each primitive vertex is tested:
1782          * - if it is rendered, if it have to be rendered (according distance);
1783          * - if it is not rendered, if it have to be not rendered (according distance).
1784          * Due to "top-left" rasterization rule check position is
1785          * different from rendering vertex position.
1786          *
1787          * Also one pixel width guarding box is checked to be clear.
1788          */
1789
1790         const glw::Functions& gl                           = m_context.getRenderContext().getFunctions();
1791         const glw::GLuint        n_sub_grid_cells = 3; /* Tested distance is positive for all vertices in the primitive;
1792          * Tested distance is negative for 0th vertex in the primitive;
1793          * Tested distance is negative for all vertices in the primitive;
1794          */
1795         const glw::GLuint        sub_grid_cell_size =
1796                 ((primitive_mode == PRIMITIVE_MODE_LINES) ? 8 : (primitive_mode == PRIMITIVE_MODE_POINTS) ? 3 : 8);
1797
1798         const glw::GLuint grid_cell_size = n_sub_grid_cells * sub_grid_cell_size;
1799         const glw::GLuint n_primitive_vertices =
1800                 ((primitive_mode == PRIMITIVE_MODE_LINES) ? 2 : (primitive_mode == PRIMITIVE_MODE_POINTS) ? 1 : 3);
1801
1802         const glw::GLuint n_grid_cells_x                           = culldistances_array_size != 0 ? culldistances_array_size : 1;
1803         const glw::GLuint n_grid_cells_y                           = clipdistances_array_size != 0 ? clipdistances_array_size : 1;
1804         const glw::GLuint n_pervertex_float_attributes = clipdistances_array_size + culldistances_array_size +
1805                                                                                                          2 /* vertex' draw x, y */ + 2 /* vertex' checkpoint x, y */;
1806         const glw::GLuint n_primitives_total     = n_grid_cells_x * n_sub_grid_cells * n_grid_cells_y * n_sub_grid_cells;
1807         const glw::GLuint n_vertices_total               = n_primitives_total * n_primitive_vertices;
1808         const glw::GLuint offsets_line_draw_x[2] = {
1809                 1, sub_grid_cell_size - 1
1810         }; /* vertex x offsets to subgrid cell origin for line primitive     */
1811         const glw::GLuint offsets_line_draw_y[2] = {
1812                 1, sub_grid_cell_size - 1
1813         }; /* vertex y offsets to subgrid cell origin for line primitive     */
1814         const glw::GLuint offsets_line_checkpoint_x[2] = {
1815                 1, sub_grid_cell_size - 2
1816         }; /* pixel x offsets to subgrid cell origin for line primitive      */
1817         const glw::GLuint offsets_line_checkpoint_y[2] = {
1818                 1, sub_grid_cell_size - 2
1819         }; /* pixel y offsets to subgrid cell origin for line primitive      */
1820         const glw::GLuint offsets_point_draw_x[1] = {
1821                 1
1822         }; /* vertex x offsets to subgrid cell origin for point primitive    */
1823         const glw::GLuint offsets_point_draw_y[1] = {
1824                 1
1825         }; /* vertex y offsets to subgrid cell origin for point primitive    */
1826         const glw::GLuint offsets_point_checkpoint_x[1] = {
1827                 1
1828         }; /* pixel x offsets to subgrid cell origin for point primitive     */
1829         const glw::GLuint offsets_point_checkpoint_y[1] = {
1830                 1
1831         }; /* pixel y offsets to subgrid cell origin for point primitive     */
1832         const glw::GLuint offsets_triangle_draw_x[3] = {
1833                 1, sub_grid_cell_size - 1, sub_grid_cell_size - 1
1834         }; /* vertex x offsets to subgrid cell origin for triangle primitive */
1835         const glw::GLuint offsets_triangle_draw_y[3] = {
1836                 1, sub_grid_cell_size - 1, 1
1837         }; /* vertex y offsets to subgrid cell origin for triangle primitive */
1838         const glw::GLuint offsets_triangle_checkpoint_x[3] = {
1839                 1, sub_grid_cell_size - 2, sub_grid_cell_size - 2
1840         }; /* pixel x offsets to subgrid cell origin for triangle primitive  */
1841         const glw::GLuint offsets_triangle_checkpoint_y[3] = {
1842                 1, sub_grid_cell_size - 2, 1
1843         }; /* pixel y offsets to subgrid cell origin for triangle primitive  */
1844         const glw::GLfloat offsets_pixel_center_x = (primitive_mode == PRIMITIVE_MODE_POINTS) ? 0.5f : 0;
1845         const glw::GLfloat offsets_pixel_center_y = (primitive_mode == PRIMITIVE_MODE_POINTS) ? 0.5f : 0;
1846         /* Clear data left from previous tests. */
1847         m_bo_data.clear();
1848
1849         /* No data to render */
1850         m_render_primitives = 0;
1851         m_render_vertices   = 0;
1852
1853         /* Preallocate space for bo_points_count */
1854         m_bo_data.reserve(n_vertices_total * n_pervertex_float_attributes);
1855
1856         /* Generate test data for cell_y-th clip distance */
1857         for (glw::GLuint cell_y = 0; cell_y < n_grid_cells_y; cell_y++)
1858         {
1859                 /* Generate test data for cell_x-th cull distance */
1860                 for (glw::GLuint cell_x = 0; cell_x < n_grid_cells_x; cell_x++)
1861                 {
1862                         /* Check clip distance sub cases:
1863                          * 0. Tested distance is positive for all vertices in the primitive;
1864                          * 1. Tested distance is negative for 0th vertex in the primitive;
1865                          * 2. Tested distance is negative for all vertices in the primitive;
1866                          */
1867                         for (glw::GLuint n_sub_cell_y = 0; n_sub_cell_y < n_sub_grid_cells; n_sub_cell_y++)
1868                         {
1869                                 /* Check cull distance sub cases:
1870                                  * 0. Tested distance is positive for all vertices in the primitive;
1871                                  * 1. Tested distance is negative for 0th vertex in the primitive;
1872                                  * 2. Tested distance is negative for all vertices in the primitive;
1873                                  */
1874                                 for (glw::GLuint n_sub_cell_x = 0; n_sub_cell_x < n_sub_grid_cells; n_sub_cell_x++)
1875                                 {
1876                                         /* Generate vertices in primitive */
1877                                         for (glw::GLuint n_primitive_vertex = 0; n_primitive_vertex < n_primitive_vertices;
1878                                                  n_primitive_vertex++)
1879                                         {
1880                                                 /* Fill in clipdistance array for the n_primitive_vertex vertex in primitive */
1881                                                 for (glw::GLuint n_clipdistance_entry = 0; n_clipdistance_entry < clipdistances_array_size;
1882                                                          n_clipdistance_entry++)
1883                                                 {
1884                                                         glw::GLfloat distance_value = 0.0f;
1885                                                         bool             negative               = true;
1886
1887                                                         /* Special approach to tested clipdistance entry. */
1888                                                         if (n_clipdistance_entry == cell_y)
1889                                                         {
1890                                                                 /* The primitive vertex should be affected by the clip distance */
1891                                                                 switch (n_sub_cell_y)
1892                                                                 {
1893                                                                 case 0:
1894                                                                 {
1895                                                                         /* subgrid row 0: all primitive vertices have tested distance value positive */
1896                                                                         negative = false;
1897
1898                                                                         break;
1899                                                                 }
1900                                                                 case 1:
1901                                                                 {
1902                                                                         /* subgrid row 1: tested distance value for 0th primitive vertex is negative,
1903                                                                          all other primitive vertices have tested distance value positive */
1904                                                                         negative = (n_primitive_vertex == 0) ? true : false;
1905
1906                                                                         break;
1907                                                                 }
1908                                                                 case 2:
1909                                                                 {
1910                                                                         /* subgrid row 2: tested distance value is negative for all primitive vertices */
1911                                                                         negative = true;
1912
1913                                                                         break;
1914                                                                 }
1915                                                                 default:
1916                                                                         TCU_FAIL("Invalid subgrid cell index");
1917                                                                 }
1918
1919                                                                 distance_value = (negative ? -1.0f : 1.0f) * glw::GLfloat(n_clipdistance_entry + 1);
1920                                                         }
1921                                                         else
1922                                                         {
1923                                                                 /* For clip distances other than tested: assign positive value to avoid its influence. */
1924                                                                 distance_value = glw::GLfloat(clipdistances_array_size + n_clipdistance_entry + 1);
1925                                                         }
1926
1927                                                         m_bo_data.push_back(distance_value / glw::GLfloat(clipdistances_array_size));
1928                                                 } /* for (all gl_ClipDistance[] array values) */
1929
1930                                                 /* Fill in culldistance array for the n_primitive_vertex vertex in primitive */
1931                                                 for (glw::GLuint n_culldistance_entry = 0; n_culldistance_entry < culldistances_array_size;
1932                                                          n_culldistance_entry++)
1933                                                 {
1934                                                         glw::GLfloat distance_value = 0.0f;
1935                                                         bool             negative               = true;
1936
1937                                                         /* Special approach to tested culldistance entry. */
1938                                                         if (n_culldistance_entry == cell_x)
1939                                                         {
1940                                                                 /* The primitive vertex should be affected by the cull distance */
1941                                                                 switch (n_sub_cell_x)
1942                                                                 {
1943                                                                 case 0:
1944                                                                 {
1945                                                                         /* subgrid column 0: all primitive vertices have tested distance value positive */
1946                                                                         negative = false;
1947
1948                                                                         break;
1949                                                                 }
1950                                                                 case 1:
1951                                                                 {
1952                                                                         /* subgrid column 1: tested distance value for 0th primitive vertex is negative,
1953                                                                          all other primitive vertices have tested distance value positive */
1954                                                                         negative = (n_primitive_vertex == 0) ? true : false;
1955
1956                                                                         break;
1957                                                                 }
1958                                                                 case 2:
1959                                                                 {
1960                                                                         /* subgrid column 2: tested distance value is negative for all primitive vertices */
1961                                                                         negative = true;
1962
1963                                                                         break;
1964                                                                 }
1965                                                                 default:
1966                                                                         TCU_FAIL("Invalid subgrid cell index");
1967                                                                 }
1968
1969                                                                 distance_value = (negative ? -1.0f : 1.0f) * glw::GLfloat(n_culldistance_entry + 1);
1970                                                         }
1971                                                         else
1972                                                         {
1973                                                                 /* For cull distances other than tested: assign 0th vertex negative value,
1974                                                                  to check absence of between-distances influence. */
1975                                                                 if (n_primitive_vertices > 1 && n_primitive_vertex == 0)
1976                                                                 {
1977                                                                         distance_value = -glw::GLfloat(culldistances_array_size + n_culldistance_entry + 1);
1978                                                                 }
1979                                                                 else
1980                                                                 {
1981                                                                         /* This culldistance is out of interest: assign positive value. */
1982                                                                         distance_value = glw::GLfloat(culldistances_array_size + n_culldistance_entry + 1);
1983                                                                 }
1984                                                         }
1985
1986                                                         m_bo_data.push_back(distance_value / glw::GLfloat(culldistances_array_size));
1987                                                 } /* for (all gl_CullDistance[] array values) */
1988
1989                                                 /* Generate primitve vertex draw and checkpoint coordinates */
1990                                                 glw::GLint vertex_draw_pixel_offset_x           = 0;
1991                                                 glw::GLint vertex_draw_pixel_offset_y           = 0;
1992                                                 glw::GLint vertex_checkpoint_pixel_offset_x = 0;
1993                                                 glw::GLint vertex_checkpoint_pixel_offset_y = 0;
1994
1995                                                 switch (primitive_mode)
1996                                                 {
1997                                                 case PRIMITIVE_MODE_LINES:
1998                                                 {
1999                                                         vertex_draw_pixel_offset_x               = offsets_line_draw_x[n_primitive_vertex];
2000                                                         vertex_draw_pixel_offset_y               = offsets_line_draw_y[n_primitive_vertex];
2001                                                         vertex_checkpoint_pixel_offset_x = offsets_line_checkpoint_x[n_primitive_vertex];
2002                                                         vertex_checkpoint_pixel_offset_y = offsets_line_checkpoint_y[n_primitive_vertex];
2003
2004                                                         break;
2005                                                 }
2006
2007                                                 case PRIMITIVE_MODE_POINTS:
2008                                                 {
2009                                                         vertex_draw_pixel_offset_x               = offsets_point_draw_x[n_primitive_vertex];
2010                                                         vertex_draw_pixel_offset_y               = offsets_point_draw_y[n_primitive_vertex];
2011                                                         vertex_checkpoint_pixel_offset_x = offsets_point_checkpoint_x[n_primitive_vertex];
2012                                                         vertex_checkpoint_pixel_offset_y = offsets_point_checkpoint_y[n_primitive_vertex];
2013
2014                                                         break;
2015                                                 }
2016
2017                                                 case PRIMITIVE_MODE_TRIANGLES:
2018                                                 {
2019                                                         vertex_draw_pixel_offset_x               = offsets_triangle_draw_x[n_primitive_vertex];
2020                                                         vertex_draw_pixel_offset_y               = offsets_triangle_draw_y[n_primitive_vertex];
2021                                                         vertex_checkpoint_pixel_offset_x = offsets_triangle_checkpoint_x[n_primitive_vertex];
2022                                                         vertex_checkpoint_pixel_offset_y = offsets_triangle_checkpoint_y[n_primitive_vertex];
2023
2024                                                         break;
2025                                                 }
2026
2027                                                 default:
2028                                                         TCU_FAIL("Unknown primitive mode");
2029                                                 }
2030
2031                                                 /* Origin of sub_cell */
2032                                                 glw::GLint sub_cell_origin_x = cell_x * grid_cell_size + n_sub_cell_x * sub_grid_cell_size;
2033                                                 glw::GLint sub_cell_origin_y = cell_y * grid_cell_size + n_sub_cell_y * sub_grid_cell_size;
2034                                                 /* Normalized texture coordinates of vertex draw position. */
2035                                                 glw::GLfloat x =
2036                                                         (glw::GLfloat(sub_cell_origin_x + vertex_draw_pixel_offset_x) + offsets_pixel_center_x) /
2037                                                         glw::GLfloat(m_to_width);
2038                                                 glw::GLfloat y =
2039                                                         (glw::GLfloat(sub_cell_origin_y + vertex_draw_pixel_offset_y) + offsets_pixel_center_y) /
2040                                                         glw::GLfloat(m_to_height);
2041                                                 /* Normalized texture coordinates of vertex checkpoint position. */
2042                                                 glw::GLfloat checkpoint_x = glw::GLfloat(sub_cell_origin_x + vertex_checkpoint_pixel_offset_x) /
2043                                                                                                         glw::GLfloat(m_to_width);
2044                                                 glw::GLfloat checkpoint_y = glw::GLfloat(sub_cell_origin_y + vertex_checkpoint_pixel_offset_y) /
2045                                                                                                         glw::GLfloat(m_to_height);
2046
2047                                                 /* Add vertex draw coordinates into buffer. */
2048                                                 m_bo_data.push_back(x);
2049                                                 m_bo_data.push_back(y);
2050
2051                                                 /* Add vertex checkpoint coordinates into buffer. */
2052                                                 m_bo_data.push_back(checkpoint_x);
2053                                                 m_bo_data.push_back(checkpoint_y);
2054                                         } /* for (all vertices in primitive) */
2055                                 }        /* for (all horizontal sub cells) */
2056                         }                 /* for (all vertical sub cells) */
2057                 }                         /* for (all horizontal cells) */
2058         }                                 /* for (all vertical cells) */
2059
2060         /* Sanity check: make sure we pushed required amount of data */
2061         DE_ASSERT(m_bo_data.size() == n_vertices_total * n_pervertex_float_attributes);
2062
2063         /* Save number of primitives to render */
2064         m_render_primitives  = n_primitives_total;
2065         m_render_vertices       = n_vertices_total;
2066         m_sub_grid_cell_size = sub_grid_cell_size;
2067
2068         /* Copy the data to the buffer object */
2069         gl.bindBuffer(GL_ARRAY_BUFFER, m_bo_id);
2070         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer() call failed.");
2071
2072         gl.bufferData(GL_ARRAY_BUFFER, m_bo_data.size() * sizeof(glw::GLfloat), &m_bo_data[0], GL_STATIC_DRAW);
2073         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData() call failed.");
2074
2075         DE_ASSERT(m_po_id != 0);
2076
2077         /* Bind VAO data to program */
2078         glw::GLint po_clipdistance_array_location = -1;
2079         glw::GLint po_culldistance_array_location = -1;
2080         glw::GLint po_position_location                   = -1;
2081
2082         /* Retrieve clipdistance and culldistance attribute locations */
2083         gl.bindVertexArray(m_vao_id);
2084         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
2085
2086         po_clipdistance_array_location = gl.getAttribLocation(m_po_id, "clipdistance_data[0]");
2087         po_culldistance_array_location = gl.getAttribLocation(m_po_id, "culldistance_data[0]");
2088         po_position_location               = gl.getAttribLocation(m_po_id, "position");
2089
2090         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetAttribLocation() call(s) failed.");
2091
2092         if (clipdistances_array_size > 0)
2093         {
2094                 DE_ASSERT(po_clipdistance_array_location != -1);
2095         }
2096
2097         if (culldistances_array_size > 0)
2098         {
2099                 DE_ASSERT(po_culldistance_array_location != -1);
2100         }
2101
2102         DE_ASSERT(po_position_location != -1);
2103
2104         glw::GLintptr   current_offset = 0;
2105         const glw::GLint stride                 = static_cast<glw::GLint>(n_pervertex_float_attributes * sizeof(glw::GLfloat));
2106
2107         gl.bindVertexArray(m_vao_id);
2108         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray() call failed.");
2109
2110         for (glw::GLuint n_clipdistance_entry = 0; n_clipdistance_entry < clipdistances_array_size; ++n_clipdistance_entry)
2111         {
2112                 gl.vertexAttribPointer(po_clipdistance_array_location + n_clipdistance_entry, 1, /* size */
2113                                                            GL_FLOAT, GL_FALSE,                                                                           /* normalized */
2114                                                            stride, (const glw::GLvoid*)current_offset);
2115                 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() call failed.");
2116
2117                 gl.enableVertexAttribArray(po_clipdistance_array_location + n_clipdistance_entry);
2118                 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed.");
2119
2120                 current_offset += sizeof(glw::GLfloat);
2121         } /* for (all clip distance array value attributes) */
2122
2123         for (glw::GLuint n_culldistance_entry = 0; n_culldistance_entry < culldistances_array_size; ++n_culldistance_entry)
2124         {
2125                 gl.vertexAttribPointer(po_culldistance_array_location + n_culldistance_entry, 1, /* size */
2126                                                            GL_FLOAT, GL_FALSE,                                                                           /* normalized */
2127                                                            stride, (const glw::GLvoid*)current_offset);
2128                 GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() call failed.");
2129
2130                 gl.enableVertexAttribArray(po_culldistance_array_location + n_culldistance_entry);
2131                 GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed.");
2132
2133                 current_offset += sizeof(glw::GLfloat);
2134         } /* for (all cull distance array value attributes) */
2135
2136         gl.vertexAttribPointer(po_position_location, 2, /* size */
2137                                                    GL_FLOAT, GL_FALSE,          /* normalized */
2138                                                    stride, (const glw::GLvoid*)current_offset);
2139         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer() call failed");
2140
2141         gl.enableVertexAttribArray(po_position_location);
2142         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray() call failed");
2143 }
2144
2145 /** @brief Cull Distance Functional Test deinitialization */
2146 void CullDistance::FunctionalTest::deinit()
2147 {
2148         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2149
2150         if (m_fbo_id != 0)
2151         {
2152                 gl.deleteFramebuffers(1, &m_fbo_id);
2153
2154                 m_fbo_id = 0;
2155         }
2156
2157         if (m_to_id != 0)
2158         {
2159                 gl.deleteTextures(1, &m_to_id);
2160
2161                 m_to_id = 0;
2162         }
2163
2164         if (m_vao_id != 0)
2165         {
2166                 gl.deleteVertexArrays(1, &m_vao_id);
2167
2168                 m_vao_id = 0;
2169         }
2170
2171         deinitPO();
2172 }
2173
2174 /** @brief Cull Distance Functional Test deinitialization of OpenGL programs */
2175 void CullDistance::FunctionalTest::deinitPO()
2176 {
2177         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2178
2179         if (m_po_id != 0)
2180         {
2181                 gl.deleteProgram(m_po_id);
2182
2183                 m_po_id = 0;
2184         }
2185 }
2186
2187 /** @brief Executes single render test case
2188  *
2189  * @param [in]  clipdistances_array_size    Size of gl_ClipDistance[] array
2190  * @param [in]  culldistances_array_size    Size of gl_CullDistance[] array
2191  * @param [in]  primitive_mode              Type of primitives to be rendered (see enum _primitive_mode)
2192  * @param [in]  use_tesselation             Indicate whether to use tessellation shader
2193  * @param [in]  fetch_culldistance_from_fs  Indicate whether to fetch gl_CullDistance and gl_ClipDistance values from the fragment shader
2194  */
2195 void CullDistance::FunctionalTest::executeRenderTest(glw::GLuint         clipdistances_array_size,
2196                                                                                                          glw::GLuint     culldistances_array_size,
2197                                                                                                          _primitive_mode primitive_mode, bool use_tesselation,
2198                                                                                                          bool fetch_culldistance_from_fs)
2199 {
2200         const glw::Functions& gl                                                  = m_context.getRenderContext().getFunctions();
2201         glw::GLenum                       mode                                            = GL_NONE;
2202         glw::GLuint                       n_clipped_vertices_real        = 0;
2203         glw::GLuint                       n_culled_primitives_real      = 0;
2204         glw::GLuint                       n_not_clipped_vertices_real = 0;
2205         const glw::GLuint        primitive_vertices_count =
2206                 ((primitive_mode == PRIMITIVE_MODE_LINES) ? 2 : (primitive_mode == PRIMITIVE_MODE_POINTS) ? 1 : 3);
2207         const glw::GLuint stride_in_floats =
2208                 clipdistances_array_size + culldistances_array_size + 2 /* position's x, y*/ + 2 /* checkpoint x,y */;
2209
2210         switch (primitive_mode)
2211         {
2212         case PRIMITIVE_MODE_LINES:
2213         {
2214                 mode = GL_LINES;
2215
2216                 break;
2217         }
2218         case PRIMITIVE_MODE_POINTS:
2219         {
2220                 mode = GL_POINTS;
2221
2222                 break;
2223         }
2224         case PRIMITIVE_MODE_TRIANGLES:
2225         {
2226                 mode = GL_TRIANGLES;
2227
2228                 break;
2229         }
2230         default:
2231                 TCU_FAIL("Unknown primitive mode");
2232         }
2233
2234         if (use_tesselation)
2235         {
2236                 mode = GL_PATCHES;
2237
2238                 gl.patchParameteri(GL_PATCH_VERTICES, primitive_vertices_count);
2239                 GLU_EXPECT_NO_ERROR(gl.getError(), "glPatchParameteri() call failed.");
2240         }
2241
2242         gl.clear(GL_COLOR_BUFFER_BIT);
2243         GLU_EXPECT_NO_ERROR(gl.getError(), "glClear() call failed.");
2244
2245         gl.useProgram(m_po_id);
2246         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
2247
2248         for (glw::GLuint n_clipdistance_entry = 0; n_clipdistance_entry < clipdistances_array_size; n_clipdistance_entry++)
2249         {
2250                 gl.enable(GL_CLIP_DISTANCE0 + n_clipdistance_entry);
2251                 GLU_EXPECT_NO_ERROR(gl.getError(), "gl.enable(GL_CLIP_DISTANCE)() call failed.");
2252         } /* for (all clip distance array value attributes) */
2253
2254         gl.drawArrays(mode, 0, m_render_vertices);
2255         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArray() call(s) failed.");
2256
2257         for (glw::GLuint n_clipdistance_entry = 0; n_clipdistance_entry < clipdistances_array_size; n_clipdistance_entry++)
2258         {
2259                 gl.disable(GL_CLIP_DISTANCE0 + n_clipdistance_entry);
2260                 GLU_EXPECT_NO_ERROR(gl.getError(), "gl.disable(GL_CLIP_DISTANCE)() call failed.");
2261         } /* for (all clip distance array value attributes) */
2262
2263         gl.useProgram(0);
2264         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram() call failed.");
2265
2266         /* Read generated texture into m_to_pixel_data_cache */
2267         readTexturePixels();
2268
2269         for (glw::GLint n_primitive_index = 0; n_primitive_index < m_render_primitives; n_primitive_index++)
2270         {
2271                 glw::GLuint base_index_of_primitive              = n_primitive_index * primitive_vertices_count * stride_in_floats;
2272                 bool            primitive_culled                         = false;
2273                 glw::GLint  primitive_culled_by_distance = -1;
2274
2275                 /* Check the bounding box is clear */
2276                 glw::GLuint base_index_of_vertex          = base_index_of_primitive;
2277                 glw::GLuint checkpoint_position_index = base_index_of_vertex + clipdistances_array_size +
2278                                                                                                 culldistances_array_size + 2 /* ignore vertex coordinates */;
2279                 glw::GLint checkpoint_x = glw::GLint(glw::GLfloat(m_to_width) * m_bo_data[checkpoint_position_index]);
2280                 glw::GLint checkpoint_y = glw::GLint(glw::GLfloat(m_to_height) * m_bo_data[checkpoint_position_index + 1]);
2281                 glw::GLint origin_x             = checkpoint_x - 1;
2282                 glw::GLint origin_y             = checkpoint_y - 1;
2283                 for (glw::GLint pixel_offset = 0; pixel_offset < m_sub_grid_cell_size; pixel_offset++)
2284                 {
2285                         if (readRedPixelValue(origin_x + pixel_offset, origin_y) != 0)
2286                         {
2287                                 TCU_FAIL("Top edge of bounding box is overwritten");
2288                         }
2289
2290                         if (readRedPixelValue(origin_x + m_sub_grid_cell_size - 1, origin_y + pixel_offset) != 0)
2291                         {
2292                                 TCU_FAIL("Right edge of bounding box is overwritten");
2293                         }
2294
2295                         if (readRedPixelValue(origin_x + m_sub_grid_cell_size - 1 - pixel_offset,
2296                                                                   origin_y + m_sub_grid_cell_size - 1) != 0)
2297                         {
2298                                 TCU_FAIL("Bottom edge of bounding box is overwritten");
2299                         }
2300
2301                         if (readRedPixelValue(origin_x, origin_y + m_sub_grid_cell_size - 1 - pixel_offset) != 0)
2302                         {
2303                                 TCU_FAIL("Left edge of bounding box is overwritten");
2304                         }
2305                 }
2306
2307                 /* Determine if primitive has been culled */
2308                 for (glw::GLuint n_culldistance_entry = 0; n_culldistance_entry < culldistances_array_size;
2309                          n_culldistance_entry++)
2310                 {
2311                         bool distance_negative_in_all_primitive_vertices = true;
2312
2313                         for (glw::GLuint n_primitive_vertex = 0; n_primitive_vertex < primitive_vertices_count;
2314                                  n_primitive_vertex++)
2315                         {
2316                                 glw::GLint base_index_of_vertex_internal =
2317                                         base_index_of_primitive + n_primitive_vertex * stride_in_floats;
2318                                 glw::GLint      culldistance_array_offset = base_index_of_vertex_internal + clipdistances_array_size;
2319                                 glw::GLfloat* vertex_culldistance_array = &m_bo_data[culldistance_array_offset];
2320
2321                                 if (vertex_culldistance_array[n_culldistance_entry] >= 0)
2322                                 {
2323                                         /* Primitive is not culled, due to one of its distances is not negative */
2324                                         distance_negative_in_all_primitive_vertices = false;
2325
2326                                         /* Skip left vertices for this distance */
2327                                         break;
2328                                 }
2329                         }
2330
2331                         /* The distance is negative in all primitive vertices, so this distance culls the primitive */
2332                         if (distance_negative_in_all_primitive_vertices)
2333                         {
2334                                 primitive_culled                         = true;
2335                                 primitive_culled_by_distance = n_culldistance_entry;
2336
2337                                 n_culled_primitives_real++;
2338
2339                                 /* Skip left distances from check */
2340                                 break;
2341                         }
2342                 }
2343
2344                 /* Validate culling */
2345                 if (primitive_culled)
2346                 {
2347                         /* Check whether primitive was culled and all its vertices are invisible */
2348                         for (glw::GLuint n_primitive_vertex = 0; n_primitive_vertex < primitive_vertices_count;
2349                                  n_primitive_vertex++)
2350                         {
2351                                 glw::GLint base_index_of_vertex_internal =
2352                                         base_index_of_primitive + n_primitive_vertex * stride_in_floats;
2353                                 glw::GLint checkpoint_position_index_internal = base_index_of_vertex_internal +
2354                                                                                                                                 clipdistances_array_size + culldistances_array_size +
2355                                                                                                                                 2 /* ignore vertex coordinates */;
2356                                 glw::GLint checkpoint_x_internal =
2357                                         glw::GLint(glw::GLfloat(m_to_width) * m_bo_data[checkpoint_position_index_internal]);
2358                                 glw::GLint checkpoint_y_internal =
2359                                         glw::GLint(glw::GLfloat(m_to_height) * m_bo_data[checkpoint_position_index_internal + 1]);
2360                                 glw::GLint vertex_color_red_value = readRedPixelValue(checkpoint_x_internal, checkpoint_y_internal);
2361
2362                                 /* Make sure vertex is invisible */
2363                                 if (vertex_color_red_value != 0)
2364                                 {
2365                                         m_testCtx.getLog() << tcu::TestLog::Message << "Primitive number [" << n_primitive_index << "] "
2366                                                                            << "should be culled by distance [" << primitive_culled_by_distance << "]"
2367                                                                            << "but primitive vertex at (" << checkpoint_x << "," << checkpoint_y
2368                                                                            << ") is visible." << tcu::TestLog::EndMessage;
2369
2370                                         TCU_FAIL("Primitive is expected to be culled, but one of its vertices is visible.");
2371                                 }
2372                         }
2373
2374                         /* Primitive is culled, no reason to check clipping */
2375                         continue;
2376                 }
2377
2378                 bool all_vertices_are_clipped = true;
2379
2380                 for (glw::GLuint n_primitive_vertex = 0; n_primitive_vertex < primitive_vertices_count; n_primitive_vertex++)
2381                 {
2382                         glw::GLuint base_index_of_vertex_internal = base_index_of_primitive + n_primitive_vertex * stride_in_floats;
2383                         glw::GLuint clipdistance_array_index      = base_index_of_vertex_internal;
2384                         glw::GLuint checkpoint_position_index_internal = base_index_of_vertex_internal + clipdistances_array_size +
2385                                                                                                                          culldistances_array_size +
2386                                                                                                                          2 /* ignore vertex coordinates */;
2387                         glw::GLint checkpoint_x_internal =
2388                                 glw::GLint(glw::GLfloat(m_to_width) * m_bo_data[checkpoint_position_index_internal]);
2389                         glw::GLint checkpoint_y_internal =
2390                                 glw::GLint(glw::GLfloat(m_to_height) * m_bo_data[checkpoint_position_index_internal + 1]);
2391                         glw::GLfloat* vertex_clipdistance_array  = &m_bo_data[clipdistance_array_index];
2392                         bool              vertex_clipped                         = false;
2393                         glw::GLint      vertex_clipped_by_distance = 0;
2394                         glw::GLint      vertex_color_red_value   = readRedPixelValue(checkpoint_x_internal, checkpoint_y_internal);
2395
2396                         /* Check whether pixel should be clipped */
2397                         for (glw::GLuint n_clipdistance_entry = 0; n_clipdistance_entry < clipdistances_array_size;
2398                                  n_clipdistance_entry++)
2399                         {
2400                                 if (vertex_clipdistance_array[n_clipdistance_entry] < 0)
2401                                 {
2402                                         vertex_clipped                     = true;
2403                                         vertex_clipped_by_distance = n_clipdistance_entry;
2404
2405                                         break;
2406                                 }
2407                         }
2408
2409                         all_vertices_are_clipped &= vertex_clipped;
2410
2411                         /* Validate whether real data same as expected */
2412                         if (vertex_clipped)
2413                         {
2414                                 if (vertex_color_red_value != 0)
2415                                 {
2416                                         m_testCtx.getLog() << tcu::TestLog::Message << "In primitive number [" << n_primitive_index << "] "
2417                                                                            << "vertex at (" << checkpoint_x << "," << checkpoint_y << ") "
2418                                                                            << "should be clipped by distance [" << vertex_clipped_by_distance << "] "
2419                                                                            << "(distance value [" << vertex_clipdistance_array[vertex_clipped_by_distance]
2420                                                                            << "])" << tcu::TestLog::EndMessage;
2421
2422                                         TCU_FAIL("Vertex is expected to be clipped and invisible, while it is visible.");
2423                                 }
2424                                 else
2425                                 {
2426                                         n_clipped_vertices_real++;
2427                                 }
2428                         }
2429                         else
2430                         {
2431                                 if (vertex_color_red_value == 0)
2432                                 {
2433                                         m_testCtx.getLog() << tcu::TestLog::Message << "In primitive number [" << n_primitive_index << "] "
2434                                                                            << "vertex at (" << checkpoint_x << "," << checkpoint_y << ") "
2435                                                                            << "should not be clipped." << tcu::TestLog::EndMessage;
2436
2437                                         TCU_FAIL("Vertex is unexpectedly clipped or invisible");
2438                                 }
2439                                 else
2440                                 {
2441                                         n_not_clipped_vertices_real++;
2442                                 }
2443                         }
2444                 }
2445
2446                 if (!all_vertices_are_clipped)
2447                 {
2448                         /* Check fetched values from the shader (Point 2 of Basic Outline : "Use program that...") */
2449                         if (fetch_culldistance_from_fs)
2450                         {
2451                                 for (glw::GLuint n_primitive_vertex = 0; n_primitive_vertex < primitive_vertices_count;
2452                                          n_primitive_vertex++)
2453                                 {
2454                                         /* Get shader output value */
2455                                         glw::GLuint base_index_of_vertex_internal =
2456                                                 base_index_of_primitive + n_primitive_vertex * stride_in_floats;
2457                                         glw::GLuint checkpoint_position_index_internal =
2458                                                 base_index_of_vertex_internal + clipdistances_array_size + culldistances_array_size +
2459                                                 2 /* ignore vertex coordinates */;
2460                                         glw::GLuint culldistances_index = base_index_of_vertex_internal + clipdistances_array_size;
2461                                         glw::GLint  checkpoint_x_internal =
2462                                                 glw::GLint(glw::GLfloat(m_to_width) * m_bo_data[checkpoint_position_index_internal]);
2463                                         glw::GLint checkpoint_y_internal =
2464                                                 glw::GLint(glw::GLfloat(m_to_height) * m_bo_data[checkpoint_position_index_internal + 1]);
2465                                         glw::GLint vertex_color_red_value = readRedPixelValue(checkpoint_x_internal, checkpoint_y_internal);
2466
2467                                         /* Calculate culldistances check sum hash */
2468                                         float sum = 0.f;
2469
2470                                         for (glw::GLuint n_clipdistance_entry = 0; n_clipdistance_entry < clipdistances_array_size;
2471                                                  ++n_clipdistance_entry)
2472                                         {
2473                                                 sum += de::abs(m_bo_data[base_index_of_vertex_internal + n_clipdistance_entry]) *
2474                                                            float(n_clipdistance_entry + 1);
2475                                         }
2476
2477                                         for (glw::GLuint n_culldistance_entry = 0; n_culldistance_entry < culldistances_array_size;
2478                                                  ++n_culldistance_entry)
2479                                         {
2480                                                 sum += de::abs(m_bo_data[culldistances_index + n_culldistance_entry]) *
2481                                                            float(n_culldistance_entry + 1 + clipdistances_array_size);
2482                                         }
2483
2484                                         /* limit sum and return */
2485                                         glw::GLint sum_hash =
2486                                                 glw::GLint(sum / glw::GLfloat((clipdistances_array_size + culldistances_array_size) *
2487                                                                                                           (clipdistances_array_size + culldistances_array_size + 1)) *
2488                                                                    65535.f /* normalizing to short */);
2489                                         sum_hash = (sum_hash < 65536) ? sum_hash : 65535; /* clamping to short */
2490
2491                                         /* Compare against setup value */
2492                                         if (std::abs(vertex_color_red_value - sum_hash) > 4 /* precision 4/65536 */)
2493                                         {
2494                                                 m_testCtx.getLog() << tcu::TestLog::Message << "Primitive number [" << n_primitive_index << "] "
2495                                                                                    << "should have culldistance hash sum " << sum_hash
2496                                                                                    << "but primitive vertex at (" << checkpoint_x << "," << checkpoint_y
2497                                                                                    << ") has sum hash equal to " << vertex_color_red_value
2498                                                                                    << tcu::TestLog::EndMessage;
2499
2500                                                 TCU_FAIL("Culled distances returned from fragment shader dose not match expected values.");
2501                                         }
2502                                 }
2503                         }
2504                 }
2505         }
2506
2507         /* sub_grid cell size is 3*3 */
2508         DE_ASSERT(m_render_primitives % 9 == 0);
2509
2510         /* Sanity check */
2511         switch (primitive_mode)
2512         {
2513         case PRIMITIVE_MODE_LINES:
2514         case PRIMITIVE_MODE_TRIANGLES:
2515         {
2516                 /* Validate culled primitives */
2517                 if (culldistances_array_size == 0)
2518                 {
2519                         DE_ASSERT(n_culled_primitives_real == 0);
2520                 }
2521                 else
2522                 {
2523                         /* Each 3rd line or triangle should be culled by test design */
2524                         DE_ASSERT(glw::GLsizei(n_culled_primitives_real) == m_render_primitives / 3);
2525                 }
2526
2527                 /* Validate clipped vertices */
2528                 if (clipdistances_array_size == 0)
2529                 {
2530                         DE_ASSERT(n_clipped_vertices_real == 0);
2531                 }
2532                 else
2533                 {
2534 #if defined(DE_DEBUG) && !defined(DE_COVERAGE_BUILD)
2535                         glw::GLint one_third_of_rendered_primitives = (m_render_primitives - n_culled_primitives_real) / 3;
2536                         glw::GLint n_clipped_vertices_expected          = /* One third of primitives has 0th vertex clipped */
2537                                 one_third_of_rendered_primitives +
2538                                 /* One third of primitives clipped completely     */
2539                                 one_third_of_rendered_primitives * primitive_vertices_count;
2540
2541                         DE_ASSERT(glw::GLint(n_clipped_vertices_real) == n_clipped_vertices_expected);
2542 #endif
2543                 }
2544                 break;
2545         }
2546
2547         case PRIMITIVE_MODE_POINTS:
2548         {
2549                 /* Validate culled primitives */
2550                 if (culldistances_array_size == 0)
2551                 {
2552                         DE_ASSERT(n_culled_primitives_real == 0);
2553                 }
2554                 else
2555                 {
2556                         /* 2/3 points should be culled by test design */
2557                         DE_ASSERT(glw::GLsizei(n_culled_primitives_real) == m_render_primitives * 2 / 3);
2558                 }
2559
2560                 /* Validate clipped vertices */
2561                 if (clipdistances_array_size == 0)
2562                 {
2563                         DE_ASSERT(n_clipped_vertices_real == 0);
2564                 }
2565                 else
2566                 {
2567 #if defined(DE_DEBUG) && !defined(DE_COVERAGE_BUILD)
2568                         glw::GLint one_third_of_rendered_primitives = (m_render_primitives - n_culled_primitives_real) / 3;
2569
2570                         /* 2/3 of rendered points should be clipped by test design */
2571                         DE_ASSERT(glw::GLint(n_clipped_vertices_real) == 2 * one_third_of_rendered_primitives);
2572 #endif
2573                 }
2574
2575                 break;
2576         }
2577         default:
2578                 TCU_FAIL("Unknown primitive mode");
2579         }
2580 }
2581
2582 /** Executes test iteration.
2583  *
2584  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
2585  */
2586 tcu::TestNode::IterateResult CullDistance::FunctionalTest::iterate()
2587 {
2588         /* This test should only be executed if ARB_cull_distance is supported, or if
2589          * we're running a GL4.5 context
2590          */
2591         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_cull_distance") &&
2592                 !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)))
2593         {
2594                 throw tcu::NotSupportedError("GL_ARB_cull_distance is not supported");
2595         }
2596
2597         const glw::Functions& gl                        = m_context.getRenderContext().getFunctions();
2598         bool                              has_succeeded = true;
2599         bool is_core = glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5));
2600
2601         /* Retrieve important GL constant values */
2602         glw::GLint gl_max_clip_distances_value                                   = 0;
2603         glw::GLint gl_max_combined_clip_and_cull_distances_value = 0;
2604         glw::GLint gl_max_cull_distances_value                                   = 0;
2605
2606         gl.getIntegerv(GL_MAX_CLIP_DISTANCES, &gl_max_clip_distances_value);
2607         gl.getIntegerv(GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES, &gl_max_combined_clip_and_cull_distances_value);
2608         gl.getIntegerv(GL_MAX_CULL_DISTANCES, &gl_max_cull_distances_value);
2609         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetIntegerv() call(s) failed.");
2610
2611         gl.genTextures(1, &m_to_id);
2612         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenTextures() call failed.");
2613
2614         gl.bindTexture(GL_TEXTURE_2D, m_to_id);
2615         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindTexture() call failed.");
2616
2617         gl.texStorage2D(GL_TEXTURE_2D, 1, /* levels */
2618                                         GL_R32F, m_to_width, m_to_height);
2619         GLU_EXPECT_NO_ERROR(gl.getError(), "glTexStorage2D() call failed.");
2620
2621         /* Set up the draw/read FBO */
2622         gl.genFramebuffers(1, &m_fbo_id);
2623         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenFramebuffers() call failed.");
2624
2625         gl.bindFramebuffer(GL_FRAMEBUFFER, m_fbo_id);
2626         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindFramebuffer() call failed.");
2627
2628         gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_to_id, 0); /* level */
2629         GLU_EXPECT_NO_ERROR(gl.getError(), "glFramebufferTexture2D() call failed.");
2630
2631         /* Prepare a buffer object */
2632         gl.genBuffers(1, &m_bo_id);
2633         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers() call failed.");
2634
2635         /* Prepare a VAO. We will configure separately for each iteration. */
2636         gl.genVertexArrays(1, &m_vao_id);
2637         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays() call failed.");
2638
2639         /* Iterate over all functional tests */
2640         struct _test_item
2641         {
2642                 bool redeclare_clipdistances_array;
2643                 bool redeclare_culldistances_array;
2644                 bool dynamic_index_writes;
2645                 bool use_passthrough_gs;
2646                 bool use_passthrough_ts;
2647                 bool use_core_functionality;
2648                 bool fetch_culldistances;
2649         } test_items[] = { /* Use the basic outline to test the basic functionality of cull distances. */
2650                                            {
2651                                                    true,        /* redeclare_clipdistances_array */
2652                                                    true,        /* redeclare_culldistances_array */
2653                                                    false,   /* dynamic_index_writes          */
2654                                                    false,   /* use_passthrough_gs            */
2655                                                    false,   /* use_passthrough_ts            */
2656                                                    is_core, /* use_core_functionality        */
2657                                                    false        /* fetch_culldistances           */
2658                                            },
2659                                            /* Use the basic outline but don't redeclare gl_ClipDistance with a size. */
2660                                            {
2661                                                    false,   /* redeclare_clipdistances_array */
2662                                                    true,        /* redeclare_culldistances_array */
2663                                                    false,   /* dynamic_index_writes          */
2664                                                    false,   /* use_passthrough_gs            */
2665                                                    false,   /* use_passthrough_ts            */
2666                                                    is_core, /* use_core_functionality        */
2667                                                    false        /* fetch_culldistances           */
2668                                            },
2669                                            /* Use the basic outline but don't redeclare gl_CullDistance with a size. */
2670                                            {
2671                                                    true,        /* redeclare_clipdistances_array  */
2672                                                    false,   /* redeclare_culldistances_array  */
2673                                                    false,   /* dynamic_index_writes           */
2674                                                    false,   /* use_passthrough_gs             */
2675                                                    false,   /* use_passthrough_ts             */
2676                                                    is_core, /* use_core_functionality         */
2677                                                    false        /* fetch_culldistances            */
2678                                            },
2679                                            /* Use the basic outline but don't redeclare either gl_ClipDistance or
2680                  * gl_CullDistance with a size.
2681                  */
2682                                            {
2683                                                    false,   /* redeclare_clipdistances_array */
2684                                                    false,   /* redeclare_culldistances_array */
2685                                                    false,   /* dynamic_index_writes          */
2686                                                    false,   /* use_passthrough_gs            */
2687                                                    false,   /* use_passthrough_ts            */
2688                                                    is_core, /* use_core_functionality        */
2689                                                    false        /* fetch_culldistances           */
2690                                            },
2691                                            /* Use the basic outline but use dynamic indexing when writing the elements
2692                  * of the gl_ClipDistance and gl_CullDistance arrays.
2693                  */
2694                                            {
2695                                                    true,        /* redeclare_clipdistances_array */
2696                                                    true,        /* redeclare_culldistances_array */
2697                                                    true,        /* dynamic_index_writes          */
2698                                                    false,   /* use_passthrough_gs            */
2699                                                    false,   /* use_passthrough_ts            */
2700                                                    is_core, /* use_core_functionality        */
2701                                                    false        /* fetch_culldistances           */
2702                                            },
2703                                            /* Use the basic outline but add a geometry shader to the program that
2704                  * simply passes through all written clip and cull distances.
2705                  */
2706                                            {
2707                                                    true,        /* redeclare_clipdistances_array */
2708                                                    true,        /* redeclare_culldistances_array */
2709                                                    false,   /* dynamic_index_writes          */
2710                                                    true,        /* use_passthrough_gs            */
2711                                                    false,   /* use_passthrough_ts            */
2712                                                    is_core, /* use_core_functionality        */
2713                                                    false        /* fetch_culldistances           */
2714                                            },
2715                                            /* Use the basic outline but add a tessellation control and tessellation
2716                  * evaluation shader to the program which simply pass through all written
2717                  * clip and cull distances.
2718                  */
2719                                            {
2720                                                    true,        /* redeclare_clipdistances_array */
2721                                                    true,        /* redeclare_culldistances_array */
2722                                                    false,   /* dynamic_index_writes          */
2723                                                    false,   /* use_passthrough_gs            */
2724                                                    true,        /* use_passthrough_ts            */
2725                                                    is_core, /* use_core_functionality        */
2726                                                    false        /* fetch_culldistances           */
2727                                            },
2728                                            /* Test that using #extension with GL_ARB_cull_distance allows using the
2729                  * feature even with an earlier version of GLSL. Also test that the
2730                  * extension name is available as preprocessor #define.
2731                  */
2732                                            {
2733                                                    true,  /* redeclare_clipdistances_array */
2734                                                    true,  /* redeclare_culldistances_array */
2735                                                    false, /* dynamic_index_writes          */
2736                                                    false, /* use_passthrough_gs            */
2737                                                    false, /* use_passthrough_ts            */
2738                                                    false, /* use_core_functionality        */
2739                                                    false  /* fetch_culldistances           */
2740                                            },
2741                                            /* Use a program that has only a vertex shader and a fragment shader.
2742                  * The vertex shader should redeclare gl_ClipDistance with a size that
2743                  * fits all enabled cull distances. Also redeclare gl_CullDistance with a
2744                  * size. The sum of the two sizes should not be more than MAX_COMBINED_-
2745                  * CLIP_AND_CULL_DISTANCES. The fragment shader should output the cull
2746                  * distances written by the vertex shader by reading them from the built-in
2747                  * array gl_CullDistance.
2748                  */
2749                                            {
2750                                                    true,  /* redeclare_clipdistances_array */
2751                                                    true,  /* redeclare_culldistances_array */
2752                                                    false, /* dynamic_index_writes          */
2753                                                    false, /* use_passthrough_gs            */
2754                                                    false, /* use_passthrough_ts            */
2755                                                    false, /* use_core_functionality        */
2756                                                    true   /* fetch_culldistances           */
2757                                            }
2758         };
2759         const glw::GLuint n_test_items = sizeof(test_items) / sizeof(test_items[0]);
2760
2761         gl.viewport(0, 0, m_to_width, m_to_height);
2762         GLU_EXPECT_NO_ERROR(gl.getError(), "glViewport() call failed.");
2763
2764         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
2765         GLU_EXPECT_NO_ERROR(gl.getError(), "glClearColor() call failed.");
2766
2767         for (glw::GLuint n_test_item = 0; n_test_item < n_test_items; ++n_test_item)
2768         {
2769                 /* Check for OpenGL feature support */
2770                 if (test_items[n_test_item].use_passthrough_ts)
2771                 {
2772                         if (!glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 0)) &&
2773                                 !m_context.getContextInfo().isExtensionSupported("GL_ARB_tessellation_shader"))
2774                         {
2775                                 continue; // no tessellation shader support
2776                         }
2777                 }
2778
2779                 const _test_item&        current_test_item                                              = test_items[n_test_item];
2780                 const _primitive_mode primitive_modes[PRIMITIVE_MODE_COUNT] = { PRIMITIVE_MODE_LINES, PRIMITIVE_MODE_POINTS,
2781                                                                                                                                                 PRIMITIVE_MODE_TRIANGLES };
2782
2783                 for (glw::GLuint primitive_mode_index = 0; primitive_mode_index < PRIMITIVE_MODE_COUNT; ++primitive_mode_index)
2784                 {
2785                         _primitive_mode primitive_mode = primitive_modes[primitive_mode_index];
2786
2787                         /* Iterate over a set of gl_ClipDistances[] and gl_CullDistances[] array sizes */
2788                         for (glw::GLint n_iteration = 0; n_iteration <= gl_max_combined_clip_and_cull_distances_value;
2789                                  ++n_iteration)
2790                         {
2791                                 glw::GLuint clipdistances_array_size = 0;
2792                                 glw::GLuint culldistances_array_size = 0;
2793
2794                                 if (n_iteration != 0 && n_iteration <= gl_max_clip_distances_value)
2795                                 {
2796                                         clipdistances_array_size = n_iteration;
2797                                 }
2798
2799                                 if ((gl_max_combined_clip_and_cull_distances_value - n_iteration) < gl_max_cull_distances_value)
2800                                 {
2801                                         culldistances_array_size = gl_max_combined_clip_and_cull_distances_value - n_iteration;
2802                                 }
2803                                 else
2804                                 {
2805                                         culldistances_array_size = gl_max_cull_distances_value;
2806                                 }
2807
2808                                 if (clipdistances_array_size == 0 && culldistances_array_size == 0)
2809                                 {
2810                                         /* Skip the dummy iteration */
2811                                         continue;
2812                                 }
2813
2814                                 if (current_test_item.fetch_culldistances && (primitive_mode != PRIMITIVE_MODE_POINTS))
2815                                 {
2816                                         continue;
2817                                 }
2818
2819                                 /* Create a program to run */
2820                                 buildPO(clipdistances_array_size, culldistances_array_size, current_test_item.dynamic_index_writes,
2821                                                 primitive_mode, current_test_item.redeclare_clipdistances_array,
2822                                                 current_test_item.redeclare_culldistances_array, current_test_item.use_core_functionality,
2823                                                 current_test_item.use_passthrough_gs, current_test_item.use_passthrough_ts,
2824                                                 current_test_item.fetch_culldistances);
2825
2826                                 /* Initialize VAO data */
2827                                 configureVAO(clipdistances_array_size, culldistances_array_size, primitive_mode);
2828
2829                                 /* Run GLSL program and check results */
2830                                 executeRenderTest(clipdistances_array_size, culldistances_array_size, primitive_mode,
2831                                                                   current_test_item.use_passthrough_ts, current_test_item.fetch_culldistances);
2832
2833                         } /* for (all iterations) */
2834                 }        /* for (all test modes) */
2835         }                 /* for (all test items) */
2836
2837         /* All done */
2838         if (has_succeeded)
2839         {
2840                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2841         }
2842         else
2843         {
2844                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
2845         }
2846
2847         return STOP;
2848 }
2849
2850 /** Returns pixel red component read from texture at position x, y.
2851  *
2852  *  @param x x-coordinate to read pixel color component from
2853  *  @param y y-coordinate to read pixel color component from
2854  **/
2855 glw::GLint CullDistance::FunctionalTest::readRedPixelValue(glw::GLint x, glw::GLint y)
2856 {
2857         glw::GLint result = -1;
2858
2859         DE_ASSERT(x >= 0 && (glw::GLuint)x < m_to_width);
2860         DE_ASSERT(y >= 0 && (glw::GLuint)y < m_to_height);
2861
2862         result = m_to_pixel_data_cache[(m_to_width * y + x) * m_to_pixel_data_cache_color_components];
2863
2864         return result;
2865 }
2866
2867 /** Reads texture into m_to_pixel_data_cache.
2868  *  Texture size determined by fields m_to_width, m_to_height
2869  **/
2870 void CullDistance::FunctionalTest::readTexturePixels()
2871 {
2872         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2873
2874         m_to_pixel_data_cache.clear();
2875
2876         m_to_pixel_data_cache.resize(m_to_width * m_to_height * m_to_pixel_data_cache_color_components);
2877
2878         /* Read vertex from texture */
2879         gl.readPixels(0,                   /* x      */
2880                                   0,               /* y      */
2881                                   m_to_width,  /* width  */
2882                                   m_to_height, /* height */
2883                                   GL_RGBA, GL_UNSIGNED_SHORT, &m_to_pixel_data_cache[0]);
2884         GLU_EXPECT_NO_ERROR(gl.getError(), "glReadPixels() call failed.");
2885 }
2886
2887 /** Constructor.
2888  *
2889  *  @param context Rendering context handle.
2890  **/
2891 CullDistance::NegativeTest::NegativeTest(deqp::Context& context)
2892         : TestCase(context, "negative", "Cull Distance Negative Test")
2893         , m_fs_id(0)
2894         , m_po_id(0)
2895         , m_temp_buffer(DE_NULL)
2896         , m_vs_id(0)
2897 {
2898         /* Left blank on purpose */
2899 }
2900
2901 /** @brief Cull Distance Negative Test deinitialization */
2902 void CullDistance::NegativeTest::deinit()
2903 {
2904         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2905
2906         if (m_fs_id != 0)
2907         {
2908                 gl.deleteShader(m_fs_id);
2909
2910                 m_fs_id = 0;
2911         }
2912
2913         if (m_po_id != 0)
2914         {
2915                 gl.deleteProgram(m_po_id);
2916
2917                 m_po_id = 0;
2918         }
2919
2920         if (m_vs_id != 0)
2921         {
2922                 gl.deleteShader(m_vs_id);
2923
2924                 m_vs_id = 0;
2925         }
2926
2927         if (m_temp_buffer != DE_NULL)
2928         {
2929                 delete[] m_temp_buffer;
2930
2931                 m_temp_buffer = DE_NULL;
2932         }
2933 }
2934
2935 /** @brief Get string description of test with given parameters
2936  *
2937  *  @param [in] n_test_iteration                    Test iteration number
2938  *  @param [in] should_redeclare_output_variables   Indicate whether test redeclared gl_ClipDistance and gl_CullDistance
2939  *  @param [in] use_dynamic_index_based_writes      Indicate whether test used dynamic index-based setters
2940  *
2941  *  @return String containing description.
2942  */
2943 std::string CullDistance::NegativeTest::getTestDescription(int n_test_iteration, bool should_redeclare_output_variables,
2944                                                                                                                    bool use_dynamic_index_based_writes)
2945 {
2946         std::stringstream stream;
2947
2948         stream << "Test iteration [" << n_test_iteration << "] which uses a vertex shader that:\n\n"
2949                    << ((should_redeclare_output_variables) ?
2950                                    "* redeclares gl_ClipDistance and gl_CullDistance arrays\n" :
2951                                    "* does not redeclare gl_ClipDistance and gl_CullDistance arrays\n")
2952                    << ((use_dynamic_index_based_writes) ? "* uses dynamic index-based writes\n" : "* uses static writes\n");
2953
2954         return stream.str();
2955 }
2956
2957 /** Executes test iteration.
2958  *
2959  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
2960  */
2961 tcu::TestNode::IterateResult CullDistance::NegativeTest::iterate()
2962 {
2963         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2964
2965         /* Build the test shaders. */
2966         const glw::GLchar* token_dynamic_index_based_writes = "DYNAMIC_INDEX_BASED_WRITES";
2967         const glw::GLchar* token_insert_static_writes           = "INSERT_STATIC_WRITES";
2968         const glw::GLchar* token_n_gl_clipdistance_entries  = "N_GL_CLIPDISTANCE_ENTRIES";
2969         const glw::GLchar* token_n_gl_culldistance_entries  = "N_GL_CULLDISTANCE_ENTRIES";
2970         const glw::GLchar* token_redeclare_output_variables = "REDECLARE_OUTPUT_VARIABLES";
2971
2972         const glw::GLchar* fs_body = "#version 130\n"
2973                                                                  "\n"
2974                                                                  "void main()\n"
2975                                                                  "{\n"
2976                                                                  "}\n";
2977
2978         const glw::GLchar* vs_body_preamble = "#version 130\n"
2979                                                                                   "\n"
2980                                                                                   "    #extension GL_ARB_cull_distance : require\n"
2981                                                                                   "\n";
2982
2983         const glw::GLchar* vs_body_main = "#ifdef REDECLARE_OUTPUT_VARIABLES\n"
2984                                                                           "    out float gl_ClipDistance[N_GL_CLIPDISTANCE_ENTRIES];\n"
2985                                                                           "    out float gl_CullDistance[N_GL_CULLDISTANCE_ENTRIES];\n"
2986                                                                           "#endif\n"
2987                                                                           "\n"
2988                                                                           "void main()\n"
2989                                                                           "{\n"
2990                                                                           "#ifdef DYNAMIC_INDEX_BASED_WRITES\n"
2991                                                                           "    for (int n_clipdistance_entry = 0;\n"
2992                                                                           "             n_clipdistance_entry < N_GL_CLIPDISTANCE_ENTRIES;\n"
2993                                                                           "           ++n_clipdistance_entry)\n"
2994                                                                           "    {\n"
2995                                                                           "        gl_ClipDistance[n_clipdistance_entry] = float(n_clipdistance_entry) / "
2996                                                                           "float(N_GL_CLIPDISTANCE_ENTRIES);\n"
2997                                                                           "    }\n"
2998                                                                           "\n"
2999                                                                           "    for (int n_culldistance_entry = 0;\n"
3000                                                                           "             n_culldistance_entry < N_GL_CULLDISTANCE_ENTRIES;\n"
3001                                                                           "           ++n_culldistance_entry)\n"
3002                                                                           "    {\n"
3003                                                                           "        gl_CullDistance[n_culldistance_entry] = float(n_culldistance_entry) / "
3004                                                                           "float(N_GL_CULLDISTANCE_ENTRIES);\n"
3005                                                                           "    }\n"
3006                                                                           "#else\n"
3007                                                                           "    INSERT_STATIC_WRITES\n"
3008                                                                           "#endif\n"
3009                                                                           "}\n";
3010
3011         /* This test should only be executed if ARB_cull_distance is supported, or if
3012          * we're running a GL4.5 context
3013          */
3014         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_cull_distance") &&
3015                 !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::core(4, 5)))
3016         {
3017                 throw tcu::NotSupportedError("GL_ARB_cull_distance is not supported");
3018         }
3019
3020         /* It only makes sense to run this test if GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES
3021          * is lower than a sum of GL_MAX_CLIP_DISTANCES and GL_MAX_CLIP_CULL_DISTANCES.
3022          */
3023         glw::GLint  gl_max_clip_distances_value                                   = 0;
3024         glw::GLint  gl_max_combined_clip_and_cull_distances_value = 0;
3025         glw::GLint  gl_max_cull_distances_value                                   = 0;
3026         glw::GLuint n_gl_clipdistance_array_items                                 = 0;
3027         std::string n_gl_clipdistance_array_items_string;
3028         glw::GLuint n_gl_culldistance_array_items = 0;
3029         std::string n_gl_culldistance_array_items_string;
3030         std::string static_write_shader_body_part;
3031
3032         gl.getIntegerv(GL_MAX_CLIP_DISTANCES, &gl_max_clip_distances_value);
3033         gl.getIntegerv(GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES, &gl_max_combined_clip_and_cull_distances_value);
3034         gl.getIntegerv(GL_MAX_CULL_DISTANCES, &gl_max_cull_distances_value);
3035
3036         if (gl_max_clip_distances_value + gl_max_cull_distances_value < gl_max_combined_clip_and_cull_distances_value)
3037         {
3038                 m_testCtx.getLog() << tcu::TestLog::Message
3039                                                    << "GL_MAX_COMBINED_CLIP_AND_CULL_DISTANCES is larger than or equal to "
3040                                                           "the sum of GL_MAX_CLIP_DISTANCES and GL_MAX_CULL_DISTANCES. Skipping."
3041                                                    << tcu::TestLog::EndMessage;
3042
3043                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
3044
3045                 return STOP;
3046         }
3047
3048         n_gl_clipdistance_array_items = gl_max_clip_distances_value;
3049         n_gl_culldistance_array_items = gl_max_combined_clip_and_cull_distances_value - gl_max_clip_distances_value + 1;
3050
3051         /* Determine the number of items we will want the gl_ClipDistance and gl_CullDistance arrays
3052          * to hold for test iterations that will re-declare the built-in output variables.
3053          */
3054         {
3055                 std::stringstream temp_sstream;
3056
3057                 temp_sstream << n_gl_clipdistance_array_items;
3058
3059                 n_gl_clipdistance_array_items_string = temp_sstream.str();
3060         }
3061
3062         {
3063                 std::stringstream temp_sstream;
3064
3065                 temp_sstream << n_gl_culldistance_array_items;
3066
3067                 n_gl_culldistance_array_items_string = temp_sstream.str();
3068         }
3069
3070         /* Form the "static write" shader body part. */
3071         {
3072                 std::stringstream temp_sstream;
3073
3074                 temp_sstream << "gl_ClipDistance[" << n_gl_clipdistance_array_items_string.c_str() << "] = 0.0f;\n"
3075                                          << "gl_CullDistance[" << n_gl_culldistance_array_items_string.c_str() << "] = 0.0f;\n";
3076
3077                 static_write_shader_body_part = temp_sstream.str();
3078         }
3079
3080         /* Prepare GL objects before we continue */
3081         glw::GLint compile_status = GL_FALSE;
3082
3083         m_fs_id = gl.createShader(GL_FRAGMENT_SHADER);
3084         m_po_id = gl.createProgram();
3085         m_vs_id = gl.createShader(GL_VERTEX_SHADER);
3086
3087         GLU_EXPECT_NO_ERROR(gl.getError(), "glCreateProgram() / glCreateShader() calls failed.");
3088
3089         gl.attachShader(m_po_id, m_fs_id);
3090         gl.attachShader(m_po_id, m_vs_id);
3091
3092         GLU_EXPECT_NO_ERROR(gl.getError(), "glAttachShader() call(s) failed.");
3093
3094         gl.shaderSource(m_fs_id, 1,                     /* count */
3095                                         &fs_body, DE_NULL); /* length */
3096         GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
3097
3098         gl.compileShader(m_fs_id);
3099         GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed.");
3100
3101         gl.getShaderiv(m_fs_id, GL_COMPILE_STATUS, &compile_status);
3102         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
3103
3104         if (compile_status == GL_FALSE)
3105         {
3106                 TCU_FAIL("Fragment shader failed to compile.");
3107         }
3108
3109         /* Run three separate test iterations. */
3110         struct _test_item
3111         {
3112                 bool should_redeclare_output_variables;
3113                 bool use_dynamic_index_based_writes;
3114         } test_items[] = { /* Negative Test 1 */
3115                                            { true, false },
3116
3117                                            /* Negative Test 2 */
3118                                            { false, false },
3119
3120                                            /* Negative Test 3 */
3121                                            { false, true }
3122         };
3123         const unsigned int n_test_items = sizeof(test_items) / sizeof(test_items[0]);
3124
3125         for (unsigned int n_test_item = 0; n_test_item < n_test_items; ++n_test_item)
3126         {
3127                 const _test_item& current_test_item = test_items[n_test_item];
3128
3129                 /* Prepare vertex shader body */
3130                 std::size_t               token_position = std::string::npos;
3131                 std::stringstream vs_body_sstream;
3132                 std::string               vs_body_string;
3133
3134                 vs_body_sstream << vs_body_preamble << "\n";
3135
3136                 if (current_test_item.should_redeclare_output_variables)
3137                 {
3138                         vs_body_sstream << "#define " << token_redeclare_output_variables << "\n";
3139                 }
3140
3141                 if (current_test_item.use_dynamic_index_based_writes)
3142                 {
3143                         vs_body_sstream << "#define " << token_dynamic_index_based_writes << "\n";
3144                 }
3145
3146                 vs_body_sstream << vs_body_main;
3147
3148                 /* Replace tokens with meaningful values */
3149                 vs_body_string = vs_body_sstream.str();
3150
3151                 while ((token_position = vs_body_string.find(token_n_gl_clipdistance_entries)) != std::string::npos)
3152                 {
3153                         vs_body_string = vs_body_string.replace(token_position, strlen(token_n_gl_clipdistance_entries),
3154                                                                                                         n_gl_clipdistance_array_items_string);
3155                 }
3156
3157                 while ((token_position = vs_body_string.find(token_n_gl_culldistance_entries)) != std::string::npos)
3158                 {
3159                         vs_body_string = vs_body_string.replace(token_position, strlen(token_n_gl_clipdistance_entries),
3160                                                                                                         n_gl_culldistance_array_items_string);
3161                 }
3162
3163                 while ((token_position = vs_body_string.find(token_insert_static_writes)) != std::string::npos)
3164                 {
3165                         vs_body_string = vs_body_string.replace(token_position, strlen(token_insert_static_writes),
3166                                                                                                         static_write_shader_body_part);
3167                 }
3168
3169                 /* Try to compile the vertex shader */
3170                 glw::GLint  compile_status_internal = GL_FALSE;
3171                 const char* vs_body_raw_ptr                     = vs_body_string.c_str();
3172
3173                 gl.shaderSource(m_vs_id, 1,                                     /* count */
3174                                                 &vs_body_raw_ptr, DE_NULL); /* length */
3175                 GLU_EXPECT_NO_ERROR(gl.getError(), "glShaderSource() call failed.");
3176
3177                 gl.compileShader(m_vs_id);
3178                 GLU_EXPECT_NO_ERROR(gl.getError(), "glCompileShader() call failed.");
3179
3180                 gl.getShaderiv(m_vs_id, GL_COMPILE_STATUS, &compile_status_internal);
3181                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
3182
3183                 if (compile_status_internal == GL_FALSE)
3184                 {
3185                         glw::GLint buffer_size = 0;
3186
3187                         /* Log the compilation error */
3188                         m_testCtx.getLog() << tcu::TestLog::Message
3189                                                            << getTestDescription(n_test_item, current_test_item.should_redeclare_output_variables,
3190                                                                                                          current_test_item.use_dynamic_index_based_writes)
3191                                                            << "has failed (as expected) to compile with the following info log:\n\n"
3192                                                            << tcu::TestLog::EndMessage;
3193
3194                         gl.getShaderiv(m_vs_id, GL_INFO_LOG_LENGTH, &buffer_size);
3195                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderiv() call failed.");
3196
3197                         m_temp_buffer = new glw::GLchar[buffer_size + 1];
3198
3199                         memset(m_temp_buffer, 0, buffer_size + 1);
3200
3201                         gl.getShaderInfoLog(m_vs_id, buffer_size, DE_NULL, /* length */
3202                                                                 m_temp_buffer);
3203                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetShaderInfoLog() call failed.");
3204
3205                         m_testCtx.getLog() << tcu::TestLog::Message << m_temp_buffer << tcu::TestLog::EndMessage;
3206
3207                         delete[] m_temp_buffer;
3208                         m_temp_buffer = DE_NULL;
3209
3210                         /* Move on to the next iteration */
3211                         continue;
3212                 }
3213
3214                 /* Try to link the program object */
3215                 glw::GLint link_status = GL_FALSE;
3216
3217                 gl.linkProgram(m_po_id);
3218                 GLU_EXPECT_NO_ERROR(gl.getError(), "glLinkProgram() call failed.");
3219
3220                 gl.getProgramiv(m_po_id, GL_LINK_STATUS, &link_status);
3221                 GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
3222
3223                 if (link_status == GL_TRUE)
3224                 {
3225                         m_testCtx.getLog() << tcu::TestLog::Message
3226                                                            << getTestDescription(n_test_item, current_test_item.should_redeclare_output_variables,
3227                                                                                                          current_test_item.use_dynamic_index_based_writes)
3228                                                            << "has linked successfully which is invalid!" << tcu::TestLog::EndMessage;
3229
3230                         TCU_FAIL("Program object has linked successfully, even though the process should have failed.");
3231                 }
3232                 else
3233                 {
3234                         glw::GLint buffer_size = 0;
3235
3236                         m_testCtx.getLog() << tcu::TestLog::Message
3237                                                            << getTestDescription(n_test_item, current_test_item.should_redeclare_output_variables,
3238                                                                                                          current_test_item.use_dynamic_index_based_writes)
3239                                                            << "has failed (as expected) to link with the following info log:\n\n"
3240                                                            << tcu::TestLog::EndMessage;
3241
3242                         gl.getProgramiv(m_po_id, GL_INFO_LOG_LENGTH, &buffer_size);
3243                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramiv() call failed.");
3244
3245                         m_temp_buffer = new glw::GLchar[buffer_size + 1];
3246
3247                         memset(m_temp_buffer, 0, buffer_size + 1);
3248
3249                         gl.getProgramInfoLog(m_po_id, buffer_size, DE_NULL, /* length */
3250                                                                  m_temp_buffer);
3251                         GLU_EXPECT_NO_ERROR(gl.getError(), "glGetProgramInfoLog() call failed.");
3252
3253                         m_testCtx.getLog() << tcu::TestLog::Message << m_temp_buffer << tcu::TestLog::EndMessage;
3254
3255                         delete[] m_temp_buffer;
3256                         m_temp_buffer = DE_NULL;
3257                 }
3258         } /* for (all test items) */
3259
3260         /* All done */
3261         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
3262
3263         return STOP;
3264 }
3265
3266 /** Constructor.
3267  *
3268  *  @param context Rendering context.
3269  */
3270 CullDistance::Tests::Tests(deqp::Context& context) : TestCaseGroup(context, "cull_distance", "Cull Distance Test Suite")
3271 {
3272 }
3273
3274 /** Initializes the test group contents. */
3275 void CullDistance::Tests::init()
3276 {
3277         addChild(new CullDistance::APICoverageTest(m_context));
3278         addChild(new CullDistance::FunctionalTest(m_context));
3279         addChild(new CullDistance::NegativeTest(m_context));
3280 }
3281 } /* glcts namespace */