modules/gles31/stress/es31sTessellationGeometryInteractionTests.cpp

   1 /*-------------------------------------------------------------------------
   2  * drawElements Quality Program OpenGL ES 3.1 Module
   3  * -------------------------------------------------
   4  *
   5  * Copyright 2014 The Android Open Source Project
   6  *
   7  * Licensed under the Apache License, Version 2.0 (the "License");
   8  * you may not use this file except in compliance with the License.
   9  * You may obtain a copy of the License at
  10  *
  11  *      http://www.apache.org/licenses/LICENSE-2.0
  12  *
  13  * Unless required by applicable law or agreed to in writing, software
  14  * distributed under the License is distributed on an "AS IS" BASIS,
  15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16  * See the License for the specific language governing permissions and
  17  * limitations under the License.
  18  *
  19  *//*!
  20  * \file
  21  * \brief Tessellation and geometry shader interaction stress tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31sTessellationGeometryInteractionTests.hpp"
  25
  26 #include "tcuTestLog.hpp"
  27 #include "tcuRenderTarget.hpp"
  28 #include "tcuSurface.hpp"
  29 #include "tcuTextureUtil.hpp"
  30 #include "gluRenderContext.hpp"
  31 #include "gluShaderProgram.hpp"
  32 #include "gluContextInfo.hpp"
  33 #include "gluObjectWrapper.hpp"
  34 #include "gluPixelTransfer.hpp"
  35 #include "glwFunctions.hpp"
  36 #include "glwEnums.hpp"
  37 #include "deStringUtil.hpp"
  38 #include "deUniquePtr.hpp"
  39
  40 #include <sstream>
  41
  42 namespace deqp
  43 {
  44 namespace gles31
  45 {
  46 namespace Stress
  47 {
  48 namespace
  49 {
  50
  51 class AllowedRenderFailureException : public std::runtime_error
  52 {
  53 public:
  54         AllowedRenderFailureException (const char* message) : std::runtime_error(message) { }
  55 };
  56
  57 class GridRenderCase : public TestCase
  58 {
  59 public:
  60         enum Flags
  61         {
  62                 FLAG_TESSELLATION_MAX_SPEC                                              = 0x0001,
  63                 FLAG_TESSELLATION_MAX_IMPLEMENTATION                    = 0x0002,
  64                 FLAG_GEOMETRY_MAX_SPEC                                                  = 0x0004,
  65                 FLAG_GEOMETRY_MAX_IMPLEMENTATION                                = 0x0008,
  66                 FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC                              = 0x0010,
  67                 FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION    = 0x0020,
  68         };
  69
  70                                                 GridRenderCase                                  (Context& context, const char* name, const char* description, int flags);
  71                                                 ~GridRenderCase                                 (void);
  72
  73 private:
  74         void                            init                                                    (void);
  75         void                            deinit                                                  (void);
  76         IterateResult           iterate                                                 (void);
  77
  78         void                            renderTo                                                (std::vector<tcu::Surface>& dst);
  79         bool                            verifyResultLayer                               (int layerNdx, const tcu::Surface& dst);
  80
  81         const char*                     getVertexSource                                 (void);
  82         const char*                     getFragmentSource                               (void);
  83         std::string                     getTessellationControlSource    (int tessLevel);
  84         std::string                     getTessellationEvaluationSource (int tessLevel);
  85         std::string                     getGeometryShaderSource                 (int numPrimitives, int numInstances);
  86
  87         enum
  88         {
  89                 RENDER_SIZE = 256
  90         };
  91
  92         const int                       m_flags;
  93
  94         glu::ShaderProgram*     m_program;
  95         int                                     m_numLayers;
  96 };
  97
  98 GridRenderCase::GridRenderCase (Context& context, const char* name, const char* description, int flags)
  99         : TestCase              (context, name, description)
 100         , m_flags               (flags)
 101         , m_program             (DE_NULL)
 102         , m_numLayers   (1)
 103 {
 104         DE_ASSERT(((m_flags & FLAG_TESSELLATION_MAX_SPEC) == 0)                 || ((m_flags & FLAG_TESSELLATION_MAX_IMPLEMENTATION) == 0));
 105         DE_ASSERT(((m_flags & FLAG_GEOMETRY_MAX_SPEC) == 0)                             || ((m_flags & FLAG_GEOMETRY_MAX_IMPLEMENTATION) == 0));
 106         DE_ASSERT(((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC) == 0) || ((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION) == 0));
 107 }
 108
 109 GridRenderCase::~GridRenderCase (void)
 110 {
 111         deinit();
 112 }
 113
 114 void GridRenderCase::init (void)
 115 {
 116         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 117
 118         // Requirements
 119
 120         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
 121                 !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 122                 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
 123
 124         if (m_context.getRenderTarget().getWidth() < RENDER_SIZE ||
 125                 m_context.getRenderTarget().getHeight() < RENDER_SIZE)
 126                 throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" + de::toString<int>(RENDER_SIZE) + " or larger render target.");
 127
 128         // Log
 129
 130         m_testCtx.getLog()
 131                 << tcu::TestLog::Message
 132                 << "Testing tessellation and geometry shaders that output a large number of primitives.\n"
 133                 << getDescription()
 134                 << tcu::TestLog::EndMessage;
 135
 136         // Gen program
 137         {
 138                 glu::ProgramSources     sources;
 139                 int                                     tessGenLevel = -1;
 140
 141                 sources << glu::VertexSource(getVertexSource())
 142                                 << glu::FragmentSource(getFragmentSource());
 143
 144                 // Tessellation limits
 145                 {
 146                         if (m_flags & FLAG_TESSELLATION_MAX_IMPLEMENTATION)
 147                         {
 148                                 gl.getIntegerv(GL_MAX_TESS_GEN_LEVEL, &tessGenLevel);
 149                                 GLU_EXPECT_NO_ERROR(gl.getError(), "query tessellation limits");
 150                         }
 151                         else if (m_flags & FLAG_TESSELLATION_MAX_SPEC)
 152                         {
 153                                 tessGenLevel = 64;
 154                         }
 155                         else
 156                         {
 157                                 tessGenLevel = 5;
 158                         }
 159
 160                         m_testCtx.getLog()
 161                                         << tcu::TestLog::Message
 162                                         << "Tessellation level: " << tessGenLevel << ", mode = quad.\n"
 163                                         << "\tEach input patch produces " << (tessGenLevel*tessGenLevel) << " (" << (tessGenLevel*tessGenLevel*2) << " triangles)\n"
 164                                         << tcu::TestLog::EndMessage;
 165
 166                         sources << glu::TessellationControlSource(getTessellationControlSource(tessGenLevel))
 167                                         << glu::TessellationEvaluationSource(getTessellationEvaluationSource(tessGenLevel));
 168                 }
 169
 170                 // Geometry limits
 171                 {
 172                         int             geometryOutputComponents                = -1;
 173                         int             geometryOutputVertices                  = -1;
 174                         int             geometryTotalOutputComponents   = -1;
 175                         int             geometryShaderInvocations               = -1;
 176                         bool    logGeometryLimits                               = false;
 177                         bool    logInvocationLimits                             = false;
 178
 179                         if (m_flags & FLAG_GEOMETRY_MAX_IMPLEMENTATION)
 180                         {
 181                                 m_testCtx.getLog() << tcu::TestLog::Message << "Using implementation maximum geometry shader output limits." << tcu::TestLog::EndMessage;
 182
 183                                 gl.getIntegerv(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, &geometryOutputComponents);
 184                                 gl.getIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &geometryOutputVertices);
 185                                 gl.getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, &geometryTotalOutputComponents);
 186                                 GLU_EXPECT_NO_ERROR(gl.getError(), "query geometry limits");
 187
 188                                 logGeometryLimits = true;
 189                         }
 190                         else if (m_flags & FLAG_GEOMETRY_MAX_SPEC)
 191                         {
 192                                 m_testCtx.getLog() << tcu::TestLog::Message << "Using geometry shader extension minimum maximum output limits." << tcu::TestLog::EndMessage;
 193
 194                                 geometryOutputComponents = 128;
 195                                 geometryOutputVertices = 256;
 196                                 geometryTotalOutputComponents = 1024;
 197                                 logGeometryLimits = true;
 198                         }
 199                         else
 200                         {
 201                                 geometryOutputComponents = 128;
 202                                 geometryOutputVertices = 16;
 203                                 geometryTotalOutputComponents = 1024;
 204                         }
 205
 206                         if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION)
 207                         {
 208                                 gl.getIntegerv(GL_MAX_GEOMETRY_SHADER_INVOCATIONS, &geometryShaderInvocations);
 209                                 GLU_EXPECT_NO_ERROR(gl.getError(), "query geometry invocation limits");
 210
 211                                 logInvocationLimits = true;
 212                         }
 213                         else if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC)
 214                         {
 215                                 geometryShaderInvocations = 32;
 216                                 logInvocationLimits = true;
 217                         }
 218                         else
 219                         {
 220                                 geometryShaderInvocations = 4;
 221                         }
 222
 223                         if (logGeometryLimits || logInvocationLimits)
 224                         {
 225                                 tcu::MessageBuilder msg(&m_testCtx.getLog());
 226
 227                                 msg << "Geometry shader, targeting following limits:\n";
 228
 229                                 if (logGeometryLimits)
 230                                         msg     << "\tGL_MAX_GEOMETRY_OUTPUT_COMPONENTS = " << geometryOutputComponents << "\n"
 231                                                 << "\tGL_MAX_GEOMETRY_OUTPUT_VERTICES = " << geometryOutputVertices << "\n"
 232                                                 << "\tGL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = " << geometryTotalOutputComponents << "\n";
 233
 234                                 if (logInvocationLimits)
 235                                         msg << "\tGL_MAX_GEOMETRY_SHADER_INVOCATIONS = " << geometryShaderInvocations;
 236
 237                                 msg << tcu::TestLog::EndMessage;
 238                         }
 239
 240
 241                         {
 242                                 const int       numComponentsPerVertex          = 8; // vec4 pos, vec4 color
 243
 244                                 // If FLAG_GEOMETRY_SEPARATE_PRIMITIVES is not set, geometry shader fills a rectangle area in slices.
 245                                 // Each slice is a triangle strip and is generated by a single shader invocation.
 246                                 // One slice with 4 segment ends (nodes) and 3 segments:
 247                                 //    .__.__.__.
 248                                 //    |\ |\ |\ |
 249                                 //    |_\|_\|_\|
 250
 251                                 const int       numSliceNodesComponentLimit                     = geometryTotalOutputComponents / (2 * numComponentsPerVertex);                 // each node 2 vertices
 252                                 const int       numSliceNodesOutputLimit                        = geometryOutputVertices / 2;                                                                                   // each node 2 vertices
 253                                 const int       numSliceNodes                                           = de::min(numSliceNodesComponentLimit, numSliceNodesOutputLimit);
 254
 255                                 const int       numVerticesPerInvocation                        = numSliceNodes * 2;
 256                                 const int       numPrimitivesPerInvocation                      = (numSliceNodes - 1) * 2;
 257
 258                                 const int       geometryVerticesPerPrimitive            = numVerticesPerInvocation * geometryShaderInvocations;
 259                                 const int       geometryPrimitivesOutPerPrimitive       = numPrimitivesPerInvocation * geometryShaderInvocations;
 260
 261                                 m_testCtx.getLog()
 262                                         << tcu::TestLog::Message
 263                                         << "Geometry shader:\n"
 264                                         << "\tTotal output vertex count per invocation: " << (numVerticesPerInvocation) << "\n"
 265                                         << "\tTotal output primitive count per invocation: " << (numPrimitivesPerInvocation) << "\n"
 266                                         << "\tNumber of invocations per primitive: " << geometryShaderInvocations << "\n"
 267                                         << "\tTotal output vertex count per input primitive: " << (geometryVerticesPerPrimitive) << "\n"
 268                                         << "\tTotal output primitive count per input primitive: " << (geometryPrimitivesOutPerPrimitive) << "\n"
 269                                         << tcu::TestLog::EndMessage;
 270
 271                                 sources << glu::GeometrySource(getGeometryShaderSource(numPrimitivesPerInvocation, geometryShaderInvocations));
 272
 273                                 m_testCtx.getLog()
 274                                         << tcu::TestLog::Message
 275                                         << "Program:\n"
 276                                         << "\tTotal program output vertices count per input patch: " << (tessGenLevel*tessGenLevel*2 * geometryVerticesPerPrimitive) << "\n"
 277                                         << "\tTotal program output primitive count per input patch: " << (tessGenLevel*tessGenLevel*2 * geometryPrimitivesOutPerPrimitive) << "\n"
 278                                         << tcu::TestLog::EndMessage;
 279                         }
 280                 }
 281
 282                 m_program = new glu::ShaderProgram(m_context.getRenderContext(), sources);
 283                 m_testCtx.getLog() << *m_program;
 284                 if (!m_program->isOk())
 285                         throw tcu::TestError("failed to build program");
 286         }
 287 }
 288
 289 void GridRenderCase::deinit (void)
 290 {
 291         delete m_program;
 292         m_program = DE_NULL;
 293 }
 294
 295 GridRenderCase::IterateResult GridRenderCase::iterate (void)
 296 {
 297         std::vector<tcu::Surface>       renderedLayers  (m_numLayers);
 298         bool                                            allLayersOk             = true;
 299
 300         for (int ndx = 0; ndx < m_numLayers; ++ndx)
 301                 renderedLayers[ndx].setSize(RENDER_SIZE, RENDER_SIZE);
 302
 303         m_testCtx.getLog() << tcu::TestLog::Message << "Rendering single point at the origin. Expecting yellow and green colored grid-like image. (High-frequency grid may appear unicolored)." << tcu::TestLog::EndMessage;
 304
 305         try
 306         {
 307                 renderTo(renderedLayers);
 308         }
 309         catch (const AllowedRenderFailureException& ex)
 310         {
 311                 // Got accepted failure
 312                 m_testCtx.getLog()
 313                         << tcu::TestLog::Message
 314                         << "Could not render, reason: " << ex.what() << "\n"
 315                         << "Failure is allowed."
 316                         << tcu::TestLog::EndMessage;
 317
 318                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 319                 return STOP;
 320         }
 321
 322         for (int ndx = 0; ndx < m_numLayers; ++ndx)
 323                 allLayersOk &= verifyResultLayer(ndx, renderedLayers[ndx]);
 324
 325         if (allLayersOk)
 326                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 327         else
 328                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
 329         return STOP;
 330 }
 331
 332 void GridRenderCase::renderTo (std::vector<tcu::Surface>& dst)
 333 {
 334         const glw::Functions&                   gl                                      = m_context.getRenderContext().getFunctions();
 335         const int                                               positionLocation        = gl.getAttribLocation(m_program->getProgram(), "a_position");
 336         const glu::VertexArray                  vao                                     (m_context.getRenderContext());
 337
 338         if (positionLocation == -1)
 339                 throw tcu::TestError("Attribute a_position location was -1");
 340
 341         gl.viewport(0, 0, dst.front().getWidth(), dst.front().getHeight());
 342         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
 343         GLU_EXPECT_NO_ERROR(gl.getError(), "viewport");
 344
 345         gl.bindVertexArray(*vao);
 346         GLU_EXPECT_NO_ERROR(gl.getError(), "bind vao");
 347
 348         gl.useProgram(m_program->getProgram());
 349         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
 350
 351         gl.patchParameteri(GL_PATCH_VERTICES, 1);
 352         GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
 353
 354         gl.vertexAttrib4f(positionLocation, 0.0f, 0.0f, 0.0f, 1.0f);
 355
 356         // clear viewport
 357         gl.clear(GL_COLOR_BUFFER_BIT);
 358
 359         // draw
 360         {
 361                 glw::GLenum glerror;
 362
 363                 gl.drawArrays(GL_PATCHES, 0, 1);
 364
 365                 // allow always OOM
 366                 glerror = gl.getError();
 367                 if (glerror == GL_OUT_OF_MEMORY)
 368                         throw AllowedRenderFailureException("got GL_OUT_OF_MEMORY while drawing");
 369
 370                 GLU_EXPECT_NO_ERROR(glerror, "draw patches");
 371         }
 372
 373         // Read layers
 374
 375         glu::readPixels(m_context.getRenderContext(), 0, 0, dst.front().getAccess());
 376         GLU_EXPECT_NO_ERROR(gl.getError(), "read pixels");
 377 }
 378
 379 bool GridRenderCase::verifyResultLayer (int layerNdx, const tcu::Surface& image)
 380 {
 381         tcu::Surface    errorMask       (image.getWidth(), image.getHeight());
 382         bool                    foundError      = false;
 383
 384         tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));
 385
 386         m_testCtx.getLog() << tcu::TestLog::Message << "Verifying output layer " << layerNdx  << tcu::TestLog::EndMessage;
 387
 388         for (int y = 0; y < image.getHeight(); ++y)
 389         for (int x = 0; x < image.getWidth(); ++x)
 390         {
 391                 const int               threshold       = 8;
 392                 const tcu::RGBA color           = image.getPixel(x, y);
 393
 394                 // Color must be a linear combination of green and yellow
 395                 if (color.getGreen() < 255 - threshold || color.getBlue() > threshold)
 396                 {
 397                         errorMask.setPixel(x, y, tcu::RGBA::red());
 398                         foundError = true;
 399                 }
 400         }
 401
 402         if (!foundError)
 403         {
 404                 m_testCtx.getLog()
 405                         << tcu::TestLog::Message << "Image valid." << tcu::TestLog::EndMessage
 406                         << tcu::TestLog::ImageSet("ImageVerification", "Image verification")
 407                         << tcu::TestLog::Image("Result", "Rendered result", image.getAccess())
 408                         << tcu::TestLog::EndImageSet;
 409                 return true;
 410         }
 411         else
 412         {
 413                 m_testCtx.getLog()
 414                         << tcu::TestLog::Message << "Image verification failed, found invalid pixels." << tcu::TestLog::EndMessage
 415                         << tcu::TestLog::ImageSet("ImageVerification", "Image verification")
 416                         << tcu::TestLog::Image("Result", "Rendered result", image.getAccess())
 417                         << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask.getAccess())
 418                         << tcu::TestLog::EndImageSet;
 419                 return false;
 420         }
 421 }
 422
 423 const char* GridRenderCase::getVertexSource (void)
 424 {
 425         return  "#version 310 es\n"
 426                         "in highp vec4 a_position;\n"
 427                         "void main (void)\n"
 428                         "{\n"
 429                         "       gl_Position = a_position;\n"
 430                         "}\n";
 431 }
 432
 433 const char* GridRenderCase::getFragmentSource (void)
 434 {
 435         return  "#version 310 es\n"
 436                         "flat in mediump vec4 v_color;\n"
 437                         "layout(location = 0) out mediump vec4 fragColor;\n"
 438                         "void main (void)\n"
 439                         "{\n"
 440                         "       fragColor = v_color;\n"
 441                         "}\n";
 442 }
 443
 444 std::string GridRenderCase::getTessellationControlSource (int tessLevel)
 445 {
 446         std::ostringstream buf;
 447
 448         buf <<  "#version 310 es\n"
 449                         "#extension GL_EXT_tessellation_shader : require\n"
 450                         "layout(vertices=1) out;\n"
 451                         "\n"
 452                         "void main()\n"
 453                         "{\n"
 454                         "       gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 455                         "       gl_TessLevelOuter[0] = " << tessLevel << ".0;\n"
 456                         "       gl_TessLevelOuter[1] = " << tessLevel << ".0;\n"
 457                         "       gl_TessLevelOuter[2] = " << tessLevel << ".0;\n"
 458                         "       gl_TessLevelOuter[3] = " << tessLevel << ".0;\n"
 459                         "       gl_TessLevelInner[0] = " << tessLevel << ".0;\n"
 460                         "       gl_TessLevelInner[1] = " << tessLevel << ".0;\n"
 461                         "}\n";
 462
 463         return buf.str();
 464 }
 465
 466 std::string GridRenderCase::getTessellationEvaluationSource (int tessLevel)
 467 {
 468         std::ostringstream buf;
 469
 470         buf <<  "#version 310 es\n"
 471                         "#extension GL_EXT_tessellation_shader : require\n"
 472                         "layout(quads) in;\n"
 473                         "\n"
 474                         "out mediump ivec2 v_tessellationGridPosition;\n"
 475                         "\n"
 476                         "// note: No need to use precise gl_Position since position does not depend on order\n"
 477                         "void main (void)\n"
 478                         "{\n"
 479                         "       // Fill the whole viewport\n"
 480                         "       gl_Position = vec4(gl_TessCoord.x * 2.0 - 1.0, gl_TessCoord.y * 2.0 - 1.0, 0.0, 1.0);\n"
 481                         "       // Calculate position in tessellation grid\n"
 482                         "       v_tessellationGridPosition = ivec2(round(gl_TessCoord.xy * float(" << tessLevel << ")));\n"
 483                         "}\n";
 484
 485         return buf.str();
 486 }
 487
 488 std::string GridRenderCase::getGeometryShaderSource (int numPrimitives, int numInstances)
 489 {
 490         std::ostringstream buf;
 491
 492         buf     <<      "#version 310 es\n"
 493                         "#extension GL_EXT_geometry_shader : require\n"
 494                         "layout(triangles, invocations=" << numInstances << ") in;\n"
 495                         "layout(triangle_strip, max_vertices=" << (numPrimitives + 2) << ") out;\n"
 496                         "\n"
 497                         "in mediump ivec2 v_tessellationGridPosition[];\n"
 498                         "flat out highp vec4 v_color;\n"
 499                         "\n"
 500                         "void main ()\n"
 501                         "{\n"
 502                         "       const float equalThreshold = 0.001;\n"
 503                         "       const float gapOffset = 0.0001; // subdivision performed by the geometry shader might produce gaps. Fill potential gaps by enlarging the output slice a little.\n"
 504                         "\n"
 505                         "       // Input triangle is generated from an axis-aligned rectangle by splitting it in half\n"
 506                         "       // Original rectangle can be found by finding the bounding AABB of the triangle\n"
 507                         "       vec4 aabb = vec4(min(gl_in[0].gl_Position.x, min(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
 508                         "                        min(gl_in[0].gl_Position.y, min(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)),\n"
 509                         "                        max(gl_in[0].gl_Position.x, max(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
 510                         "                        max(gl_in[0].gl_Position.y, max(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)));\n"
 511                         "\n"
 512                         "       // Location in tessellation grid\n"
 513                         "       ivec2 gridPosition = ivec2(min(v_tessellationGridPosition[0], min(v_tessellationGridPosition[1], v_tessellationGridPosition[2])));\n"
 514                         "\n"
 515                         "       // Which triangle of the two that split the grid cell\n"
 516                         "       int numVerticesOnBottomEdge = 0;\n"
 517                         "       for (int ndx = 0; ndx < 3; ++ndx)\n"
 518                         "               if (abs(gl_in[ndx].gl_Position.y - aabb.w) < equalThreshold)\n"
 519                         "                       ++numVerticesOnBottomEdge;\n"
 520                         "       bool isBottomTriangle = numVerticesOnBottomEdge == 2;\n"
 521                         "\n"
 522                         "       // Fill the input area with slices\n"
 523                         "       // Upper triangle produces slices only to the upper half of the quad and vice-versa\n"
 524                         "       float triangleOffset = (isBottomTriangle) ? ((aabb.w + aabb.y) / 2.0) : (aabb.y);\n"
 525                         "       // Each slice is a invocation\n"
 526                         "       float sliceHeight = (aabb.w - aabb.y) / float(2 * " << numInstances << ");\n"
 527                         "       float invocationOffset = float(gl_InvocationID) * sliceHeight;\n"
 528                         "\n"
 529                         "       vec4 outputSliceArea;\n"
 530                         "       outputSliceArea.x = aabb.x - gapOffset;\n"
 531                         "       outputSliceArea.y = triangleOffset + invocationOffset - gapOffset;\n"
 532                         "       outputSliceArea.z = aabb.z + gapOffset;\n"
 533                         "       outputSliceArea.w = triangleOffset + invocationOffset + sliceHeight + gapOffset;\n""\n"
 534                         "       // Draw slice\n"
 535                         "       for (int ndx = 0; ndx < " << ((numPrimitives+2)/2) << "; ++ndx)\n"
 536                         "       {\n"
 537                         "               vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
 538                         "               vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
 539                         "               vec4 outputColor = (((gl_InvocationID + ndx) % 2) == 0) ? (green) : (yellow);\n"
 540                         "               float xpos = mix(outputSliceArea.x, outputSliceArea.z, float(ndx) / float(" << (numPrimitives/2) << "));\n"
 541                         "\n"
 542                         "               gl_Position = vec4(xpos, outputSliceArea.y, 0.0, 1.0);\n"
 543                         "               v_color = outputColor;\n"
 544                         "               EmitVertex();\n"
 545                         "\n"
 546                         "               gl_Position = vec4(xpos, outputSliceArea.w, 0.0, 1.0);\n"
 547                         "               v_color = outputColor;\n"
 548                         "               EmitVertex();\n"
 549                         "       }\n"
 550                         "}\n";
 551
 552         return buf.str();
 553 }
 554
 555 } // anonymous
 556
 557 TessellationGeometryInteractionTests::TessellationGeometryInteractionTests (Context& context)
 558         : TestCaseGroup(context, "tessellation_geometry_interaction", "Tessellation and geometry shader interaction stress tests")
 559 {
 560 }
 561
 562 TessellationGeometryInteractionTests::~TessellationGeometryInteractionTests (void)
 563 {
 564 }
 565
 566 void TessellationGeometryInteractionTests::init (void)
 567 {
 568         tcu::TestCaseGroup* const multilimitGroup = new tcu::TestCaseGroup(m_testCtx, "render_multiple_limits", "Various render tests");
 569
 570         addChild(multilimitGroup);
 571
 572         // .render_multiple_limits
 573         {
 574                 static const struct LimitCaseDef
 575                 {
 576                         const char*     name;
 577                         const char*     desc;
 578                         int                     flags;
 579                 } cases[] =
 580                 {
 581                         // Test multiple limits at the same time
 582
 583                         {
 584                                 "output_required_max_tessellation_max_geometry",
 585                                 "Minimum maximum tessellation level and geometry shader output vertices",
 586                                 GridRenderCase::FLAG_TESSELLATION_MAX_SPEC | GridRenderCase::FLAG_GEOMETRY_MAX_SPEC
 587                         },
 588                         {
 589                                 "output_implementation_max_tessellation_max_geometry",
 590                                 "Maximum tessellation level and geometry shader output vertices supported by the implementation",
 591                                 GridRenderCase::FLAG_TESSELLATION_MAX_IMPLEMENTATION | GridRenderCase::FLAG_GEOMETRY_MAX_IMPLEMENTATION
 592                         },
 593                         {
 594                                 "output_required_max_tessellation_max_invocations",
 595                                 "Minimum maximum tessellation level and geometry shader invocations",
 596                                 GridRenderCase::FLAG_TESSELLATION_MAX_SPEC | GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC
 597                         },
 598                         {
 599                                 "output_implementation_max_tessellation_max_invocations",
 600                                 "Maximum tessellation level and geometry shader invocations supported by the implementation",
 601                                 GridRenderCase::FLAG_TESSELLATION_MAX_IMPLEMENTATION | GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION
 602                         },
 603                         {
 604                                 "output_required_max_geometry_max_invocations",
 605                                 "Minimum maximum geometry shader output vertices and invocations",
 606                                 GridRenderCase::FLAG_GEOMETRY_MAX_SPEC | GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC
 607                         },
 608                         {
 609                                 "output_implementation_max_geometry_max_invocations",
 610                                 "Maximum geometry shader output vertices and invocations invocations supported by the implementation",
 611                                 GridRenderCase::FLAG_GEOMETRY_MAX_IMPLEMENTATION | GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION
 612                         },
 613
 614                         // Test all limits simultaneously
 615                         {
 616                                 "output_max_required",
 617                                 "Output minimum maximum number of vertices",
 618                                 GridRenderCase::FLAG_TESSELLATION_MAX_SPEC | GridRenderCase::FLAG_GEOMETRY_MAX_SPEC | GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC
 619                         },
 620                         {
 621                                 "output_max_implementation",
 622                                 "Output maximum number of vertices supported by the implementation",
 623                                 GridRenderCase::FLAG_TESSELLATION_MAX_IMPLEMENTATION | GridRenderCase::FLAG_GEOMETRY_MAX_IMPLEMENTATION | GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION
 624                         },
 625                 };
 626
 627                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ++ndx)
 628                         multilimitGroup->addChild(new GridRenderCase(m_context, cases[ndx].name, cases[ndx].desc, cases[ndx].flags));
 629         }
 630 }
 631
 632 } // Stress
 633 } // gles31
 634 } // deqp