external/openglcts/modules/gl/gl4cShaderDrawParametersTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * OpenGL Conformance Test Suite
   3  * -----------------------------
   4  *
   5  * Copyright (c) 2016 The Khronos Group Inc.
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  */ /*!
  20  * \file
  21  * \brief
  22  */ /*-------------------------------------------------------------------*/
  23
  24 /**
  25  */ /*!
  26  * \file  gl4cShaderDrawParametersTests.cpp
  27  * \brief Conformance tests for the GL_ARB_shader_draw_parameters functionality.
  28  */ /*-------------------------------------------------------------------*/
  29
  30 #include "gl4cShaderDrawParametersTests.hpp"
  31 #include "gluContextInfo.hpp"
  32 #include "gluDefs.hpp"
  33 #include "gluDrawUtil.hpp"
  34 #include "gluShaderProgram.hpp"
  35 #include "glwEnums.hpp"
  36 #include "glwFunctions.hpp"
  37 #include "tcuRenderTarget.hpp"
  38 #include "tcuTestLog.hpp"
  39
  40 using namespace glw;
  41 using namespace glu;
  42
  43 namespace gl4cts
  44 {
  45
  46 const char* sdp_compute_extensionCheck = "#version 450 core\n"
  47                                                                                  "\n"
  48                                                                                  "#extension GL_ARB_shader_draw_parameters : require\n"
  49                                                                                  "\n"
  50                                                                                  "#ifndef GL_ARB_shader_draw_parameters\n"
  51                                                                                  "  #error GL_ARB_shader_draw_parameters not defined\n"
  52                                                                                  "#else\n"
  53                                                                                  "  #if (GL_ARB_shader_draw_parameters != 1)\n"
  54                                                                                  "    #error GL_ARB_shader_draw_parameters wrong value\n"
  55                                                                                  "  #endif\n"
  56                                                                                  "#endif // GL_ARB_shader_draw_parameters\n"
  57                                                                                  "\n"
  58                                                                                  "layout (local_size_x = 1, local_size_y = 1, local_size_z = 1) in;\n"
  59                                                                                  "\n"
  60                                                                                  "void main()\n"
  61                                                                                  "{\n"
  62                                                                                  "}\n";
  63
  64 static const char* sdp_vertShader = "#version 450\n"
  65                                                                         "\n"
  66                                                                         "#extension GL_ARB_shader_draw_parameters : enable\n"
  67                                                                         "\n"
  68                                                                         "in vec3 vertex;\n"
  69                                                                         "out vec3 color;\n"
  70                                                                         "\n"
  71                                                                         "void main()\n"
  72                                                                         "{\n"
  73                                                                         "    float hOffset = float(gl_BaseVertexARB) / 5.0;\n"
  74                                                                         "    float vOffset = float(gl_BaseInstanceARB) / 5.0;\n"
  75                                                                         "    color = vec3(0.0);\n"
  76                                                                         "    if (gl_DrawIDARB % 3 == 0) color.r = 1;\n"
  77                                                                         "    else if (gl_DrawIDARB % 3 == 1) color.g = 1;\n"
  78                                                                         "    else if (gl_DrawIDARB % 3 == 2) color.b = 1;\n"
  79                                                                         "    gl_Position = vec4(vertex + vec3(hOffset, vOffset, 0), 1);\n"
  80                                                                         "}\n";
  81
  82 static const char* sdp_fragShader = "#version 450\n"
  83                                                                         "\n"
  84                                                                         "#extension GL_ARB_shader_draw_parameters : enable\n"
  85                                                                         "\n"
  86                                                                         "in vec3 color;\n"
  87                                                                         "out vec4 fragColor;\n"
  88                                                                         "\n"
  89                                                                         "void main()\n"
  90                                                                         "{\n"
  91                                                                         "    fragColor = vec4(color, 1.0);\n"
  92                                                                         "}\n";
  93
  94 /** Constructor.
  95  *
  96  *  @param context     Rendering context
  97  */
  98 ShaderDrawParametersExtensionTestCase::ShaderDrawParametersExtensionTestCase(deqp::Context& context)
  99         : TestCase(context, "ShaderDrawParametersExtension",
 100                            "Verifies if GL_ARB_shader_draw_parameters extension is available for GLSL")
 101 {
 102         /* Left blank intentionally */
 103 }
 104
 105 /** Executes test iteration.
 106  *
 107  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 108  */
 109 tcu::TestNode::IterateResult ShaderDrawParametersExtensionTestCase::iterate()
 110 {
 111         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_draw_parameters"))
 112         {
 113                 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Not Supported");
 114                 return STOP;
 115         }
 116
 117         const Functions& gl = m_context.getRenderContext().getFunctions();
 118
 119         std::string shader = sdp_compute_extensionCheck;
 120
 121         ProgramSources sources;
 122         sources << ComputeSource(shader);
 123         ShaderProgram program(gl, sources);
 124
 125         if (!program.isOk())
 126         {
 127                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 128                 m_testCtx.getLog() << tcu::TestLog::Message << "Checking shader preprocessor directives failed. Source:\n"
 129                                                    << shader.c_str() << "InfoLog:\n"
 130                                                    << program.getShaderInfo(SHADERTYPE_COMPUTE).infoLog << "\n"
 131                                                    << tcu::TestLog::EndMessage;
 132                 return STOP;
 133         }
 134
 135         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 136         return STOP;
 137 }
 138
 139 /** Constructor.
 140  *
 141  *  @param context      Rendering context
 142  *  @param name         Test case name
 143  *  @param description  Test case description
 144  */
 145 ShaderDrawParametersTestBase::ShaderDrawParametersTestBase(deqp::Context& context, const char* name,
 146                                                                                                                    const char* description)
 147         : TestCase(context, name, description)
 148         , m_vao(0)
 149         , m_arrayBuffer(0)
 150         , m_elementBuffer(0)
 151         , m_drawIndirectBuffer(0)
 152         , m_parameterBuffer(0)
 153 {
 154         /* Left blank intentionally */
 155 }
 156
 157 /** Stub init method */
 158 void ShaderDrawParametersTestBase::init()
 159 {
 160         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_shader_draw_parameters"))
 161                 TCU_THROW(NotSupportedError, "Extension GL_ARB_shader_draw_parameters not supported");
 162
 163         initChild();
 164
 165         const Functions& gl = m_context.getRenderContext().getFunctions();
 166
 167         const GLfloat vertices[] = {
 168                 -1.0f, -1.0f, 0.0f, -1.0f, -0.8f, 0.0f, -0.9f, -1.0f, 0.0f,
 169                 -0.9f, -0.8f, 0.0f, -0.8f, -1.0f, 0.0f, -0.8f, -0.8f, 0.0f,
 170         };
 171
 172         const GLushort elements[] = { 0, 1, 2, 3, 4, 5 };
 173
 174         // Generate vertex array object
 175         gl.genVertexArrays(1, &m_vao);
 176         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenVertexArrays");
 177
 178         gl.bindVertexArray(m_vao);
 179         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindVertexArray");
 180
 181         // Setup vertex array buffer
 182         gl.genBuffers(1, &m_arrayBuffer);
 183         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 184
 185         gl.bindBuffer(GL_ARRAY_BUFFER, m_arrayBuffer);
 186         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 187
 188         gl.bufferData(GL_ARRAY_BUFFER, 24 * sizeof(GLfloat), vertices, GL_STATIC_DRAW);
 189         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 190
 191         // Setup element array buffer
 192         gl.genBuffers(1, &m_elementBuffer);
 193         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 194
 195         gl.bindBuffer(GL_ELEMENT_ARRAY_BUFFER, m_elementBuffer);
 196         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 197
 198         gl.bufferData(GL_ELEMENT_ARRAY_BUFFER, 6 * sizeof(GLushort), elements, GL_STATIC_DRAW);
 199         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 200 }
 201
 202 /** Stub deinit method */
 203 void ShaderDrawParametersTestBase::deinit()
 204 {
 205         const Functions& gl = m_context.getRenderContext().getFunctions();
 206
 207         if (m_vao)
 208                 gl.deleteVertexArrays(1, &m_vao);
 209         if (m_arrayBuffer)
 210                 gl.deleteBuffers(1, &m_arrayBuffer);
 211         if (m_elementBuffer)
 212                 gl.deleteBuffers(1, &m_elementBuffer);
 213
 214         deinitChild();
 215 }
 216
 217 /** Executes test iteration.
 218  *
 219  *  @return Returns STOP when test has finished executing, CONTINUE if more iterations are needed.
 220  */
 221 tcu::TestNode::IterateResult ShaderDrawParametersTestBase::iterate()
 222 {
 223         if (draw() && verify())
 224                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 225         else
 226                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Fail");
 227
 228         return STOP;
 229 }
 230
 231 /** Draws scene using specific case parameters.
 232  *
 233  *  @return Returns true if no error occurred, false otherwise.
 234  */
 235 bool ShaderDrawParametersTestBase::draw()
 236 {
 237         const Functions& gl = m_context.getRenderContext().getFunctions();
 238
 239         ProgramSources sources = makeVtxFragSources(sdp_vertShader, sdp_fragShader);
 240         ShaderProgram  program(gl, sources);
 241
 242         if (!program.isOk())
 243         {
 244                 m_testCtx.getLog() << tcu::TestLog::Message << "Shader build failed.\n"
 245                                                    << "Vertex: " << program.getShaderInfo(SHADERTYPE_VERTEX).infoLog << "\n"
 246                                                    << "Fragment: " << program.getShaderInfo(SHADERTYPE_FRAGMENT).infoLog << "\n"
 247                                                    << "Program: " << program.getProgramInfo().infoLog << tcu::TestLog::EndMessage;
 248                 return false;
 249         }
 250
 251         gl.useProgram(program.getProgram());
 252         GLU_EXPECT_NO_ERROR(gl.getError(), "glUseProgram");
 253
 254         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
 255         gl.clear(GL_COLOR_BUFFER_BIT);
 256
 257         gl.enable(GL_BLEND);
 258         gl.blendFunc(GL_ONE, GL_ONE);
 259
 260         gl.enableVertexAttribArray(0);
 261         GLU_EXPECT_NO_ERROR(gl.getError(), "glEnableVertexAttribArray");
 262         gl.vertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, NULL);
 263         GLU_EXPECT_NO_ERROR(gl.getError(), "glVertexAttribPointer");
 264
 265         drawCommand();
 266
 267         gl.disableVertexAttribArray(0);
 268         GLU_EXPECT_NO_ERROR(gl.getError(), "glDisableVertexAttribArray");
 269
 270         gl.disable(GL_BLEND);
 271
 272         return true;
 273 }
 274
 275 /** Verifies if drawing result is as expected.
 276  *
 277  *  @return Returns true if verifying process has been successfully completed, false otherwise.
 278  */
 279 bool ShaderDrawParametersTestBase::verify()
 280 {
 281         const Functions&                 gl = m_context.getRenderContext().getFunctions();
 282         const tcu::RenderTarget& rt = m_context.getRenderContext().getRenderTarget();
 283
 284         const int width  = rt.getWidth();
 285         const int height = rt.getHeight();
 286
 287         std::vector<GLubyte> pixels;
 288         pixels.resize(width * height * 3);
 289
 290         gl.pixelStorei(GL_PACK_ALIGNMENT, 1);
 291         gl.readPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels.data());
 292         gl.pixelStorei(GL_PACK_ALIGNMENT, 4);
 293
 294         std::vector<ResultPoint>::iterator it;
 295         for (it = m_resultPoints.begin(); it != m_resultPoints.end(); ++it)
 296         {
 297                 int x    = (int)(((it->x + 1.0f) / 2) * width);
 298                 int y    = (int)(((it->y + 1.0f) / 2) * height);
 299                 int red   = (int)(it->red * 255);
 300                 int green = (int)(it->green * 255);
 301                 int blue  = (int)(it->blue * 255);
 302
 303                 if (pixels[(x + y * width) * 3 + 0] != red || pixels[(x + y * width) * 3 + 1] != green ||
 304                         pixels[(x + y * width) * 3 + 2] != blue)
 305                 {
 306                         m_testCtx.getLog() << tcu::TestLog::Message << "Verification failed (" << x << "/" << y << ")\n"
 307                                                            << "Expected point: (" << red << "," << green << "," << blue << ")\n"
 308                                                            << "Result point: (" << (int)pixels[(x + y * width) * 3 + 0] << ","
 309                                                            << (int)pixels[(x + y * width) * 3 + 1] << "," << (int)pixels[(x + y * width) * 3 + 2]
 310                                                            << ")\n"
 311                                                            << tcu::TestLog::EndMessage;
 312                         return false;
 313                 }
 314         }
 315
 316         return true;
 317 }
 318
 319 /** Child case initialization method.
 320  */
 321 void ShaderDrawParametersTestBase::initChild()
 322 {
 323         /* Do nothing */
 324 }
 325
 326 /** Child case deinitialization method.
 327   */
 328 void ShaderDrawParametersTestBase::deinitChild()
 329 {
 330         /* Do nothing */
 331 }
 332
 333 /** Child case drawing command invocation.
 334  */
 335 void ShaderDrawParametersTestBase::drawCommand()
 336 {
 337         /* Do nothing */
 338 }
 339
 340 /* ShaderDrawArraysParametersTestCase */
 341
 342 void ShaderDrawArraysParametersTestCase::initChild()
 343 {
 344         // Set expected result vector [x, y, red, green, blue]
 345         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 346         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 347         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 348         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 349 }
 350
 351 void ShaderDrawArraysParametersTestCase::deinitChild()
 352 {
 353         /* Do nothing */
 354 }
 355
 356 void ShaderDrawArraysParametersTestCase::drawCommand()
 357 {
 358         const Functions& gl = m_context.getRenderContext().getFunctions();
 359
 360         gl.drawArrays(GL_TRIANGLE_STRIP, 1, 4);
 361         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArrays");
 362 }
 363
 364 /* ---------------------------------- */
 365
 366 /* ShaderDrawElementsParametersTestCase */
 367
 368 void ShaderDrawElementsParametersTestCase::initChild()
 369 {
 370         // Set expected result vector [x, y, red, green, blue]
 371         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 372         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 373         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 374         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 375 }
 376
 377 void ShaderDrawElementsParametersTestCase::deinitChild()
 378 {
 379         /* Do nothing */
 380 }
 381
 382 void ShaderDrawElementsParametersTestCase::drawCommand()
 383 {
 384         const Functions& gl = m_context.getRenderContext().getFunctions();
 385
 386         gl.drawElements(GL_TRIANGLE_STRIP, 4, GL_UNSIGNED_SHORT, (GLvoid*)(2 * sizeof(GLushort)));
 387         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElements");
 388 }
 389
 390 /* ---------------------------------- */
 391
 392 /* ShaderDrawArraysIndirectParametersTestCase */
 393
 394 void ShaderDrawArraysIndirectParametersTestCase::initChild()
 395 {
 396         const Functions& gl = m_context.getRenderContext().getFunctions();
 397
 398         // Set expected result vector [x, y, red, green, blue]
 399         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 400         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 401         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 402         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 403
 404         const SDPDrawArraysIndirectCommand indirect[] = {
 405                 { 5, 1, 0, 0 },
 406         };
 407
 408         // Setup indirect command buffer
 409         gl.genBuffers(1, &m_drawIndirectBuffer);
 410         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 411
 412         gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_drawIndirectBuffer);
 413         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 414
 415         gl.bufferData(GL_DRAW_INDIRECT_BUFFER, 1 * sizeof(SDPDrawArraysIndirectCommand), indirect, GL_STATIC_DRAW);
 416         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 417 }
 418
 419 void ShaderDrawArraysIndirectParametersTestCase::deinitChild()
 420 {
 421         const Functions& gl = m_context.getRenderContext().getFunctions();
 422
 423         if (m_drawIndirectBuffer)
 424                 gl.deleteBuffers(1, &m_drawIndirectBuffer);
 425 }
 426
 427 void ShaderDrawArraysIndirectParametersTestCase::drawCommand()
 428 {
 429         const Functions& gl = m_context.getRenderContext().getFunctions();
 430
 431         gl.drawArraysIndirect(GL_TRIANGLE_STRIP, (GLvoid*)0);
 432         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArraysIndirect");
 433 }
 434
 435 /* ---------------------------------- */
 436
 437 /* ShaderDrawElementsIndirectParametersTestCase */
 438
 439 void ShaderDrawElementsIndirectParametersTestCase::initChild()
 440 {
 441         const Functions& gl = m_context.getRenderContext().getFunctions();
 442
 443         // Set expected result vector [x, y, red, green, blue]
 444         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 445         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 446         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 447         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 448
 449         const SDPDrawElementsIndirectCommand indirect[] = {
 450                 { 5, 1, 1, 0, 0 },
 451         };
 452
 453         // Setup indirect command buffer
 454         gl.genBuffers(1, &m_drawIndirectBuffer);
 455         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 456
 457         gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_drawIndirectBuffer);
 458         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 459
 460         gl.bufferData(GL_DRAW_INDIRECT_BUFFER, 1 * sizeof(SDPDrawElementsIndirectCommand), indirect, GL_STATIC_DRAW);
 461         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 462 }
 463
 464 void ShaderDrawElementsIndirectParametersTestCase::deinitChild()
 465 {
 466         const Functions& gl = m_context.getRenderContext().getFunctions();
 467
 468         if (m_drawIndirectBuffer)
 469                 gl.deleteBuffers(1, &m_drawIndirectBuffer);
 470 }
 471
 472 void ShaderDrawElementsIndirectParametersTestCase::drawCommand()
 473 {
 474         const Functions& gl = m_context.getRenderContext().getFunctions();
 475
 476         gl.drawElementsIndirect(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT, (GLvoid*)0);
 477         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElementsIndirect");
 478 }
 479
 480 /* ---------------------------------- */
 481
 482 /* ShaderDrawArraysInstancedParametersTestCase */
 483
 484 void ShaderDrawArraysInstancedParametersTestCase::initChild()
 485 {
 486         // Set expected result vector [x, y, red, green, blue]
 487         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 488         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 489         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 490         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 491 }
 492
 493 void ShaderDrawArraysInstancedParametersTestCase::deinitChild()
 494 {
 495         /* Do nothing */
 496 }
 497
 498 void ShaderDrawArraysInstancedParametersTestCase::drawCommand()
 499 {
 500         const Functions& gl = m_context.getRenderContext().getFunctions();
 501
 502         gl.drawArraysInstanced(GL_TRIANGLE_STRIP, 2, 4, 2);
 503         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawArraysInstanced");
 504 }
 505
 506 /* ---------------------------------- */
 507
 508 /* ShaderDrawElementsInstancedParametersTestCase */
 509
 510 void ShaderDrawElementsInstancedParametersTestCase::initChild()
 511 {
 512         // Set expected result vector [x, y, red, green, blue]
 513         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 514         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 515         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 516         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 517 }
 518
 519 void ShaderDrawElementsInstancedParametersTestCase::deinitChild()
 520 {
 521         /* Do nothing */
 522 }
 523
 524 void ShaderDrawElementsInstancedParametersTestCase::drawCommand()
 525 {
 526         const Functions& gl = m_context.getRenderContext().getFunctions();
 527
 528         gl.drawElementsInstanced(GL_TRIANGLE_STRIP, 6, GL_UNSIGNED_SHORT, (GLvoid*)0, 3);
 529         GLU_EXPECT_NO_ERROR(gl.getError(), "glDrawElementsInstanced");
 530 }
 531
 532 /* ---------------------------------- */
 533
 534 /* ShaderMultiDrawArraysParametersTestCase */
 535
 536 void ShaderMultiDrawArraysParametersTestCase::initChild()
 537 {
 538         // Set expected result vector [x, y, red, green, blue]
 539         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 540         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 1.0f, 0.0f));
 541         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 0.0f, 1.0f, 0.0f));
 542         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 543 }
 544
 545 void ShaderMultiDrawArraysParametersTestCase::deinitChild()
 546 {
 547         /* Do nothing */
 548 }
 549
 550 void ShaderMultiDrawArraysParametersTestCase::drawCommand()
 551 {
 552         const Functions& gl = m_context.getRenderContext().getFunctions();
 553
 554         const GLint   dFirst[] = { 0, 1 };
 555         const GLsizei dCount[] = { 4, 4 };
 556
 557         gl.multiDrawArrays(GL_TRIANGLE_STRIP, dFirst, dCount, 2);
 558         GLU_EXPECT_NO_ERROR(gl.getError(), "glMultiDrawArrays");
 559 }
 560
 561 /* ---------------------------------- */
 562
 563 /* ShaderMultiDrawElementsParametersTestCase */
 564
 565 void ShaderMultiDrawElementsParametersTestCase::initChild()
 566 {
 567         // Set expected result vector [x, y, red, green, blue]
 568         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 569         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 1.0f, 0.0f));
 570         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 1.0f, 0.0f));
 571         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 572 }
 573
 574 void ShaderMultiDrawElementsParametersTestCase::deinitChild()
 575 {
 576         /* Do nothing */
 577 }
 578
 579 void ShaderMultiDrawElementsParametersTestCase::drawCommand()
 580 {
 581         const Functions& gl = m_context.getRenderContext().getFunctions();
 582
 583         const GLsizei dCount[]   = { 5, 4 };
 584         const GLvoid* dIndices[] = { (GLvoid*)(1 * sizeof(GLushort)), (GLvoid*)(1 * sizeof(GLushort)) };
 585
 586         gl.multiDrawElements(GL_TRIANGLE_STRIP, dCount, GL_UNSIGNED_SHORT, dIndices, 2);
 587         GLU_EXPECT_NO_ERROR(gl.getError(), "glMultiDrawElements");
 588 }
 589
 590 /* ---------------------------------- */
 591
 592 /* ShaderMultiDrawArraysIndirectParametersTestCase */
 593
 594 void ShaderMultiDrawArraysIndirectParametersTestCase::initChild()
 595 {
 596         const Functions& gl = m_context.getRenderContext().getFunctions();
 597
 598         // Set expected result vector [x, y, red, green, blue]
 599         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 0.0f, 1.0f, 0.0f));
 600         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 1.0f, 0.0f));
 601         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 602         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 603         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.05f, 0.0f, 0.0f, 1.0f));
 604         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.15f, 0.0f, 0.0f, 0.0f));
 605         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.05f, 0.0f, 0.0f, 0.0f));
 606         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.15f, 0.0f, 0.0f, 0.0f));
 607
 608         const SDPDrawArraysIndirectCommand indirect[] = {
 609                 { 5, 1, 1, 0 }, { 4, 1, 0, 0 }, { 3, 1, 0, 1 },
 610         };
 611
 612         // Setup indirect command buffer
 613         gl.genBuffers(1, &m_drawIndirectBuffer);
 614         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 615
 616         gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_drawIndirectBuffer);
 617         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 618
 619         gl.bufferData(GL_DRAW_INDIRECT_BUFFER, 3 * sizeof(SDPDrawArraysIndirectCommand), indirect, GL_STATIC_DRAW);
 620         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 621 }
 622
 623 void ShaderMultiDrawArraysIndirectParametersTestCase::deinitChild()
 624 {
 625         const Functions& gl = m_context.getRenderContext().getFunctions();
 626
 627         if (m_drawIndirectBuffer)
 628                 gl.deleteBuffers(1, &m_drawIndirectBuffer);
 629 }
 630
 631 void ShaderMultiDrawArraysIndirectParametersTestCase::drawCommand()
 632 {
 633         const Functions& gl = m_context.getRenderContext().getFunctions();
 634
 635         gl.multiDrawArraysIndirect(GL_TRIANGLE_STRIP, (GLvoid*)0, 3, sizeof(SDPDrawArraysIndirectCommand));
 636         GLU_EXPECT_NO_ERROR(gl.getError(), "glMultiDrawArraysIndirect");
 637 }
 638
 639 /* ---------------------------------- */
 640
 641 /* ShaderMultiDrawElementsIndirectParametersTestCase */
 642
 643 void ShaderMultiDrawElementsIndirectParametersTestCase::initChild()
 644 {
 645         const Functions& gl = m_context.getRenderContext().getFunctions();
 646
 647         // Set expected result vector [x, y, red, green, blue]
 648         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 649         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 650         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 651         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 652         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.05f, 0.0f, 0.0f, 0.0f));
 653         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.15f, 0.0f, 0.0f, 0.0f));
 654         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.05f, 0.0f, 0.0f, 0.0f));
 655         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.15f, 0.0f, 1.0f, 0.0f));
 656         m_resultPoints.push_back(ResultPoint(-0.8f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 657         m_resultPoints.push_back(ResultPoint(-0.8f + 0.05f, -1.0f + 0.15f, 0.0f, 0.0f, 1.0f));
 658         m_resultPoints.push_back(ResultPoint(-0.8f + 0.15f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 659         m_resultPoints.push_back(ResultPoint(-0.8f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 660
 661         const SDPDrawElementsIndirectCommand indirect[] = {
 662                 { 4, 1, 0, 0, 0 }, { 3, 1, 3, 0, 1 }, { 3, 1, 0, 1, 0 },
 663         };
 664
 665         // Setup indirect command buffer
 666         gl.genBuffers(1, &m_drawIndirectBuffer);
 667         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 668
 669         gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_drawIndirectBuffer);
 670         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 671
 672         gl.bufferData(GL_DRAW_INDIRECT_BUFFER, 3 * sizeof(SDPDrawElementsIndirectCommand), indirect, GL_STATIC_DRAW);
 673         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 674 }
 675
 676 void ShaderMultiDrawElementsIndirectParametersTestCase::deinitChild()
 677 {
 678         const Functions& gl = m_context.getRenderContext().getFunctions();
 679
 680         if (m_drawIndirectBuffer)
 681                 gl.deleteBuffers(1, &m_drawIndirectBuffer);
 682 }
 683
 684 void ShaderMultiDrawElementsIndirectParametersTestCase::drawCommand()
 685 {
 686         const Functions& gl = m_context.getRenderContext().getFunctions();
 687
 688         gl.multiDrawElementsIndirect(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT, (GLvoid*)0, 3,
 689                                                                  sizeof(SDPDrawElementsIndirectCommand));
 690         GLU_EXPECT_NO_ERROR(gl.getError(), "glMultiDrawElementsIndirect");
 691 }
 692
 693 /* ---------------------------------- */
 694
 695 /* ShaderMultiDrawArraysIndirectCountParametersTestCase */
 696
 697 void ShaderMultiDrawArraysIndirectCountParametersTestCase::initChild()
 698 {
 699         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_indirect_parameters"))
 700                 TCU_THROW(NotSupportedError, "Extension GL_ARB_indirect_parameters not supported");
 701
 702         const Functions& gl = m_context.getRenderContext().getFunctions();
 703
 704         // Set expected result vector [x, y, red, green, blue]
 705         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 706         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 707         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 708         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 1.0f, 0.0f, 0.0f));
 709         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.05f, 0.0f, 1.0f, 0.0f));
 710         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.8f + 0.15f, 0.0f, 1.0f, 0.0f));
 711         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.05f, 0.0f, 1.0f, 0.0f));
 712         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.8f + 0.15f, 0.0f, 1.0f, 0.0f));
 713         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.6f + 0.05f, 0.0f, 0.0f, 0.0f));
 714         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -0.6f + 0.15f, 0.0f, 0.0f, 0.0f));
 715         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.6f + 0.05f, 0.0f, 0.0f, 1.0f));
 716         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -0.6f + 0.15f, 0.0f, 0.0f, 1.0f));
 717
 718         const SDPDrawArraysIndirectCommand indirect[] = {
 719                 { 5, 1, 1, 0 }, { 6, 1, 0, 1 }, { 4, 1, 2, 2 },
 720         };
 721
 722         const GLushort parameters[] = { 1, 1, 1 };
 723
 724         // Setup indirect command buffer
 725         gl.genBuffers(1, &m_drawIndirectBuffer);
 726         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 727
 728         gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_drawIndirectBuffer);
 729         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 730
 731         gl.bufferData(GL_DRAW_INDIRECT_BUFFER, 4 * sizeof(SDPDrawArraysIndirectCommand), indirect, GL_STATIC_DRAW);
 732         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 733
 734         // Setup indirect command buffer
 735         gl.genBuffers(1, &m_parameterBuffer);
 736         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 737
 738         gl.bindBuffer(GL_PARAMETER_BUFFER_ARB, m_parameterBuffer);
 739         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 740
 741         gl.bufferData(GL_PARAMETER_BUFFER_ARB, 3 * sizeof(GLushort), parameters, GL_STATIC_DRAW);
 742         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 743 }
 744
 745 void ShaderMultiDrawArraysIndirectCountParametersTestCase::deinitChild()
 746 {
 747         const Functions& gl = m_context.getRenderContext().getFunctions();
 748
 749         if (m_drawIndirectBuffer)
 750                 gl.deleteBuffers(1, &m_drawIndirectBuffer);
 751         if (m_parameterBuffer)
 752                 gl.deleteBuffers(1, &m_parameterBuffer);
 753 }
 754
 755 void ShaderMultiDrawArraysIndirectCountParametersTestCase::drawCommand()
 756 {
 757         const Functions& gl = m_context.getRenderContext().getFunctions();
 758
 759         gl.multiDrawArraysIndirectCountARB(GL_TRIANGLE_STRIP, 0, 0, 3, sizeof(SDPDrawArraysIndirectCommand));
 760         GLU_EXPECT_NO_ERROR(gl.getError(), "glMultiDrawArraysIndirect");
 761 }
 762
 763 /* ---------------------------------- */
 764
 765 /* ShaderMultiDrawElementsIndirectCountParametersTestCase */
 766
 767 void ShaderMultiDrawElementsIndirectCountParametersTestCase::initChild()
 768 {
 769         if (!m_context.getContextInfo().isExtensionSupported("GL_ARB_indirect_parameters"))
 770                 TCU_THROW(NotSupportedError, "Extension GL_ARB_indirect_parameters not supported");
 771
 772         const Functions& gl = m_context.getRenderContext().getFunctions();
 773
 774         // Set expected result vector [x, y, red, green, blue]
 775         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.05f, 1.0f, 0.0f, 0.0f));
 776         m_resultPoints.push_back(ResultPoint(-1.0f + 0.05f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 777         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.05f, 0.0f, 0.0f, 0.0f));
 778         m_resultPoints.push_back(ResultPoint(-1.0f + 0.15f, -1.0f + 0.15f, 0.0f, 0.0f, 0.0f));
 779         m_resultPoints.push_back(ResultPoint(-0.8f + 0.05f, -0.8f + 0.05f, 0.0f, 0.0f, 0.0f));
 780         m_resultPoints.push_back(ResultPoint(-0.8f + 0.05f, -0.8f + 0.15f, 0.0f, 1.0f, 1.0f));
 781         m_resultPoints.push_back(ResultPoint(-0.8f + 0.15f, -0.8f + 0.05f, 0.0f, 0.0f, 1.0f));
 782         m_resultPoints.push_back(ResultPoint(-0.8f + 0.15f, -0.8f + 0.15f, 0.0f, 0.0f, 0.0f));
 783
 784         const SDPDrawElementsIndirectCommand indirect[] = {
 785                 { 3, 1, 0, 0, 0 }, { 3, 1, 0, 1, 1 }, { 4, 1, 0, 1, 1 },
 786         };
 787
 788         const GLushort parameters[] = { 1, 1, 1 };
 789
 790         // Setup indirect command buffer
 791         gl.genBuffers(1, &m_drawIndirectBuffer);
 792         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 793
 794         gl.bindBuffer(GL_DRAW_INDIRECT_BUFFER, m_drawIndirectBuffer);
 795         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 796
 797         gl.bufferData(GL_DRAW_INDIRECT_BUFFER, 3 * sizeof(SDPDrawElementsIndirectCommand), indirect, GL_STATIC_DRAW);
 798         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 799
 800         // Setup indirect command buffer
 801         gl.genBuffers(1, &m_parameterBuffer);
 802         GLU_EXPECT_NO_ERROR(gl.getError(), "glGenBuffers");
 803
 804         gl.bindBuffer(GL_PARAMETER_BUFFER_ARB, m_parameterBuffer);
 805         GLU_EXPECT_NO_ERROR(gl.getError(), "glBindBuffer");
 806
 807         gl.bufferData(GL_PARAMETER_BUFFER_ARB, 3 * sizeof(GLushort), parameters, GL_STATIC_DRAW);
 808         GLU_EXPECT_NO_ERROR(gl.getError(), "glBufferData");
 809 }
 810
 811 void ShaderMultiDrawElementsIndirectCountParametersTestCase::deinitChild()
 812 {
 813         const Functions& gl = m_context.getRenderContext().getFunctions();
 814
 815         if (m_drawIndirectBuffer)
 816                 gl.deleteBuffers(1, &m_drawIndirectBuffer);
 817         if (m_parameterBuffer)
 818                 gl.deleteBuffers(1, &m_parameterBuffer);
 819 }
 820
 821 void ShaderMultiDrawElementsIndirectCountParametersTestCase::drawCommand()
 822 {
 823         const Functions& gl = m_context.getRenderContext().getFunctions();
 824
 825         gl.multiDrawElementsIndirectCountARB(GL_TRIANGLE_STRIP, GL_UNSIGNED_SHORT, 0, 0, 3,
 826                                                                                  sizeof(SDPDrawElementsIndirectCommand));
 827         GLU_EXPECT_NO_ERROR(gl.getError(), "glMultiDrawElementsIndirect");
 828 }
 829
 830 /* ---------------------------------- */
 831
 832 /** Constructor.
 833  *
 834  *  @param context Rendering context.
 835  */
 836 ShaderDrawParametersTests::ShaderDrawParametersTests(deqp::Context& context)
 837         : TestCaseGroup(context, "shader_draw_parameters_tests",
 838                                         "Verify conformance of GL_ARB_shader_draw_parameters implementation")
 839 {
 840 }
 841
 842 /** Initializes the test group contents. */
 843 void ShaderDrawParametersTests::init()
 844 {
 845         addChild(new ShaderDrawParametersExtensionTestCase(m_context));
 846         addChild(new ShaderDrawArraysParametersTestCase(m_context));
 847         addChild(new ShaderDrawElementsParametersTestCase(m_context));
 848         addChild(new ShaderDrawArraysIndirectParametersTestCase(m_context));
 849         addChild(new ShaderDrawElementsIndirectParametersTestCase(m_context));
 850         addChild(new ShaderDrawArraysInstancedParametersTestCase(m_context));
 851         addChild(new ShaderDrawElementsInstancedParametersTestCase(m_context));
 852         addChild(new ShaderMultiDrawArraysParametersTestCase(m_context));
 853         addChild(new ShaderMultiDrawElementsParametersTestCase(m_context));
 854         addChild(new ShaderMultiDrawArraysIndirectParametersTestCase(m_context));
 855         addChild(new ShaderMultiDrawElementsIndirectParametersTestCase(m_context));
 856         addChild(new ShaderMultiDrawArraysIndirectCountParametersTestCase(m_context));
 857         addChild(new ShaderMultiDrawElementsIndirectCountParametersTestCase(m_context));
 858 }
 859
 860 } /* gl4cts namespace */