modules/gles31/functional/es31fTessellationGeometryInteractionTests.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 tests.
  22  *//*--------------------------------------------------------------------*/
  23
  24 #include "es31fTessellationGeometryInteractionTests.hpp"
  25
  26 #include "tcuTestLog.hpp"
  27 #include "tcuRenderTarget.hpp"
  28 #include "tcuSurface.hpp"
  29 #include "tcuImageCompare.hpp"
  30 #include "tcuVectorUtil.hpp"
  31 #include "tcuTextureUtil.hpp"
  32 #include "gluRenderContext.hpp"
  33 #include "gluShaderProgram.hpp"
  34 #include "gluStrUtil.hpp"
  35 #include "gluContextInfo.hpp"
  36 #include "gluObjectWrapper.hpp"
  37 #include "gluPixelTransfer.hpp"
  38 #include "glwFunctions.hpp"
  39 #include "glwEnums.hpp"
  40 #include "deStringUtil.hpp"
  41 #include "deUniquePtr.hpp"
  42
  43 #include <sstream>
  44 #include <algorithm>
  45 #include <iterator>
  46
  47 namespace deqp
  48 {
  49 namespace gles31
  50 {
  51 namespace Functional
  52 {
  53 namespace
  54 {
  55
  56 static const char* const s_positionVertexShader =               "#version 310 es\n"
  57                                                                                                                 "in highp vec4 a_position;\n"
  58                                                                                                                 "void main (void)\n"
  59                                                                                                                 "{\n"
  60                                                                                                                 "       gl_Position = a_position;\n"
  61                                                                                                                 "}\n";
  62 static const char* const s_whiteOutputFragmentShader =  "#version 310 es\n"
  63                                                                                                                 "layout(location = 0) out mediump vec4 fragColor;\n"
  64                                                                                                                 "void main (void)\n"
  65                                                                                                                 "{\n"
  66                                                                                                                 "       fragColor = vec4(1.0);\n"
  67                                                                                                                 "}\n";
  68
  69 static bool isBlack (const tcu::RGBA& c)
  70 {
  71         return c.getRed() == 0 && c.getGreen() == 0 && c.getBlue() == 0;
  72 }
  73
  74 class IdentityShaderCase : public TestCase
  75 {
  76 public:
  77                                         IdentityShaderCase      (Context& context, const char* name, const char* description);
  78
  79 protected:
  80         const char*             getVertexSource         (void) const;
  81         const char*             getFragmentSource       (void) const;
  82 };
  83
  84 IdentityShaderCase::IdentityShaderCase (Context& context, const char* name, const char* description)
  85         : TestCase(context, name, description)
  86 {
  87 }
  88
  89 const char* IdentityShaderCase::getVertexSource (void) const
  90 {
  91         return  "#version 310 es\n"
  92                         "in highp vec4 a_position;\n"
  93                         "out highp vec4 v_vertex_color;\n"
  94                         "void main (void)\n"
  95                         "{\n"
  96                         "       gl_Position = a_position;\n"
  97                         "       v_vertex_color = vec4(a_position.x * 0.5 + 0.5, a_position.y * 0.5 + 0.5, 1.0, 0.4);\n"
  98                         "}\n";
  99 }
 100
 101 const char* IdentityShaderCase::getFragmentSource (void) const
 102 {
 103         return  "#version 310 es\n"
 104                         "in mediump vec4 v_fragment_color;\n"
 105                         "layout(location = 0) out mediump vec4 fragColor;\n"
 106                         "void main (void)\n"
 107                         "{\n"
 108                         "       fragColor = v_fragment_color;\n"
 109                         "}\n";
 110 }
 111
 112 class IdentityGeometryShaderCase : public IdentityShaderCase
 113 {
 114 public:
 115         enum CaseType
 116         {
 117                 CASE_TRIANGLES = 0,
 118                 CASE_QUADS,
 119                 CASE_ISOLINES,
 120         };
 121
 122                                         IdentityGeometryShaderCase                      (Context& context, const char* name, const char* description, CaseType caseType);
 123                                         ~IdentityGeometryShaderCase                     (void);
 124
 125 private:
 126         void                    init                                                            (void);
 127         void                    deinit                                                          (void);
 128         IterateResult   iterate                                                         (void);
 129
 130         std::string             getTessellationControlSource            (void) const;
 131         std::string             getTessellationEvaluationSource         (bool geometryActive) const;
 132         std::string             getGeometrySource                                       (void) const;
 133
 134         enum
 135         {
 136                 RENDER_SIZE = 128,
 137         };
 138
 139         const CaseType  m_case;
 140         deUint32                m_patchBuffer;
 141 };
 142
 143 IdentityGeometryShaderCase::IdentityGeometryShaderCase (Context& context, const char* name, const char* description, CaseType caseType)
 144         : IdentityShaderCase    (context, name, description)
 145         , m_case                                (caseType)
 146         , m_patchBuffer                 (0)
 147 {
 148 }
 149
 150 IdentityGeometryShaderCase::~IdentityGeometryShaderCase (void)
 151 {
 152         deinit();
 153 }
 154
 155 void IdentityGeometryShaderCase::init (void)
 156 {
 157         // Requirements
 158
 159         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
 160                 !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 161                 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
 162
 163         if (m_context.getRenderTarget().getWidth() < RENDER_SIZE ||
 164                 m_context.getRenderTarget().getHeight() < RENDER_SIZE)
 165                 throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" + de::toString<int>(RENDER_SIZE) + " or larger render target.");
 166
 167         // Log
 168
 169         m_testCtx.getLog()
 170                 << tcu::TestLog::Message
 171                 << "Testing tessellating shader program output does not change when a passthrough geometry shader is attached.\n"
 172                 << "Rendering two images, first with and second without a geometry shader. Expecting similar results.\n"
 173                 << "Using additive blending to detect overlap.\n"
 174                 << tcu::TestLog::EndMessage;
 175
 176         // Resources
 177
 178         {
 179                 static const tcu::Vec4 patchBufferData[4] =
 180                 {
 181                         tcu::Vec4( -0.9f, -0.9f, 0.0f, 1.0f ),
 182                         tcu::Vec4( -0.9f,  0.9f, 0.0f, 1.0f ),
 183                         tcu::Vec4(  0.9f, -0.9f, 0.0f, 1.0f ),
 184                         tcu::Vec4(  0.9f,  0.9f, 0.0f, 1.0f ),
 185                 };
 186
 187                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 188
 189                 gl.genBuffers(1, &m_patchBuffer);
 190                 gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
 191                 gl.bufferData(GL_ARRAY_BUFFER, sizeof(patchBufferData), patchBufferData, GL_STATIC_DRAW);
 192                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
 193         }
 194 }
 195
 196 void IdentityGeometryShaderCase::deinit (void)
 197 {
 198         if (m_patchBuffer)
 199         {
 200                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_patchBuffer);
 201                 m_patchBuffer = 0;
 202         }
 203 }
 204
 205 IdentityGeometryShaderCase::IterateResult IdentityGeometryShaderCase::iterate (void)
 206 {
 207         const float                             innerTessellationLevel  = 14.0f;
 208         const float                             outerTessellationLevel  = 14.0f;
 209         const glw::Functions&   gl                                              = m_context.getRenderContext().getFunctions();
 210         tcu::Surface                    resultWithGeometry              (RENDER_SIZE, RENDER_SIZE);
 211         tcu::Surface                    resultWithoutGeometry   (RENDER_SIZE, RENDER_SIZE);
 212
 213         const struct
 214         {
 215                 const char*                             name;
 216                 const char*                             description;
 217                 bool                                    containsGeometryShader;
 218                 tcu::PixelBufferAccess  surfaceAccess;
 219         } renderTargets[] =
 220         {
 221                 { "RenderWithGeometryShader",           "Render with geometry shader",          true,   resultWithGeometry.getAccess()          },
 222                 { "RenderWithoutGeometryShader",        "Render without geometry shader",       false,  resultWithoutGeometry.getAccess()       },
 223         };
 224
 225         gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
 226         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
 227         GLU_EXPECT_NO_ERROR(gl.getError(), "set viewport");
 228
 229         gl.enable(GL_BLEND);
 230         gl.blendFunc(GL_SRC_ALPHA, GL_ONE);
 231         gl.blendEquation(GL_FUNC_ADD);
 232         GLU_EXPECT_NO_ERROR(gl.getError(), "set blend");
 233
 234         m_testCtx.getLog() << tcu::TestLog::Message << "Tessellation level: inner " << innerTessellationLevel << ", outer " << outerTessellationLevel << tcu::TestLog::EndMessage;
 235
 236         // render with and without geometry shader
 237         for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renderTargets); ++renderNdx)
 238         {
 239                 const tcu::ScopedLogSection     section (m_testCtx.getLog(), renderTargets[renderNdx].name, renderTargets[renderNdx].description);
 240                 glu::ProgramSources                     sources;
 241
 242                 sources << glu::VertexSource(getVertexSource())
 243                                 << glu::FragmentSource(getFragmentSource())
 244                                 << glu::TessellationControlSource(getTessellationControlSource())
 245                                 << glu::TessellationEvaluationSource(getTessellationEvaluationSource(renderTargets[renderNdx].containsGeometryShader));
 246
 247                 if (renderTargets[renderNdx].containsGeometryShader)
 248                         sources << glu::GeometrySource(getGeometrySource());
 249
 250                 {
 251                         const glu::ShaderProgram        program                                 (m_context.getRenderContext(), sources);
 252                         const glu::VertexArray          vao                                             (m_context.getRenderContext());
 253                         const int                                       posLocation                             = gl.getAttribLocation(program.getProgram(), "a_position");
 254                         const int                                       innerTessellationLoc    = gl.getUniformLocation(program.getProgram(), "u_innerTessellationLevel");
 255                         const int                                       outerTessellationLoc    = gl.getUniformLocation(program.getProgram(), "u_outerTessellationLevel");
 256
 257                         m_testCtx.getLog() << program;
 258
 259                         if (!program.isOk())
 260                                 throw tcu::TestError("could not build program");
 261                         if (posLocation == -1)
 262                                 throw tcu::TestError("a_position location was -1");
 263                         if (outerTessellationLoc == -1)
 264                                 throw tcu::TestError("u_outerTessellationLevel location was -1");
 265
 266                         gl.bindVertexArray(*vao);
 267                         gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
 268                         gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
 269                         gl.enableVertexAttribArray(posLocation);
 270                         GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
 271
 272                         gl.useProgram(program.getProgram());
 273                         gl.uniform1f(outerTessellationLoc, outerTessellationLevel);
 274
 275                         if (innerTessellationLoc == -1)
 276                                 gl.uniform1f(innerTessellationLoc, innerTessellationLevel);
 277
 278                         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
 279
 280                         gl.patchParameteri(GL_PATCH_VERTICES, (m_case == CASE_TRIANGLES) ? (3): (4));
 281                         GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
 282
 283                         gl.clear(GL_COLOR_BUFFER_BIT);
 284                         GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
 285
 286                         gl.drawArrays(GL_PATCHES, 0, 4);
 287                         GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
 288
 289                         glu::readPixels(m_context.getRenderContext(), 0, 0, renderTargets[renderNdx].surfaceAccess);
 290                 }
 291         }
 292
 293         if (tcu::intThresholdPositionDeviationCompare(m_testCtx.getLog(),
 294                                                                                                   "ImageCompare",
 295                                                                                                   "Image comparison",
 296                                                                                                   resultWithoutGeometry.getAccess(),
 297                                                                                                   resultWithGeometry.getAccess(),
 298                                                                                                   tcu::UVec4(8, 8, 8, 255),
 299                                                                                                   tcu::IVec3(1, 1, 0),
 300                                                                                                   true,
 301                                                                                                   tcu::COMPARE_LOG_RESULT))
 302                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 303         else
 304                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
 305
 306         return STOP;
 307 }
 308
 309 std::string IdentityGeometryShaderCase::getTessellationControlSource (void) const
 310 {
 311         std::ostringstream buf;
 312
 313         buf <<  "#version 310 es\n"
 314                         "#extension GL_EXT_tessellation_shader : require\n"
 315                         "layout(vertices = 4) out;\n"
 316                         "\n"
 317                         "uniform highp float u_innerTessellationLevel;\n"
 318                         "uniform highp float u_outerTessellationLevel;\n"
 319                         "in highp vec4 v_vertex_color[];\n"
 320                         "out highp vec4 v_patch_color[];\n"
 321                         "\n"
 322                         "void main (void)\n"
 323                         "{\n"
 324                         "       gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 325                         "       v_patch_color[gl_InvocationID] = v_vertex_color[gl_InvocationID];\n"
 326                         "\n";
 327
 328         if (m_case == CASE_TRIANGLES)
 329                 buf <<  "       gl_TessLevelOuter[0] = u_outerTessellationLevel;\n"
 330                                 "       gl_TessLevelOuter[1] = u_outerTessellationLevel;\n"
 331                                 "       gl_TessLevelOuter[2] = u_outerTessellationLevel;\n"
 332                                 "       gl_TessLevelInner[0] = u_innerTessellationLevel;\n";
 333         else if (m_case == CASE_QUADS)
 334                 buf <<  "       gl_TessLevelOuter[0] = u_outerTessellationLevel;\n"
 335                                 "       gl_TessLevelOuter[1] = u_outerTessellationLevel;\n"
 336                                 "       gl_TessLevelOuter[2] = u_outerTessellationLevel;\n"
 337                                 "       gl_TessLevelOuter[3] = u_outerTessellationLevel;\n"
 338                                 "       gl_TessLevelInner[0] = u_innerTessellationLevel;\n"
 339                                 "       gl_TessLevelInner[1] = u_innerTessellationLevel;\n";
 340         else if (m_case == CASE_ISOLINES)
 341                 buf <<  "       gl_TessLevelOuter[0] = u_outerTessellationLevel;\n"
 342                                 "       gl_TessLevelOuter[1] = u_outerTessellationLevel;\n";
 343         else
 344                 DE_ASSERT(false);
 345
 346         buf <<  "}\n";
 347
 348         return buf.str();
 349 }
 350
 351 std::string IdentityGeometryShaderCase::getTessellationEvaluationSource (bool geometryActive) const
 352 {
 353         const char* const       colorOutputName = ((geometryActive) ? ("v_evaluated_color") : ("v_fragment_color"));
 354         std::ostringstream      buf;
 355
 356         buf <<  "#version 310 es\n"
 357                         "#extension GL_EXT_tessellation_shader : require\n"
 358                         "layout("
 359                                 << ((m_case == CASE_TRIANGLES) ? ("triangles") : (m_case == CASE_QUADS) ? ("quads") : ("isolines"))
 360                                 << ") in;\n"
 361                         "\n"
 362                         "in highp vec4 v_patch_color[];\n"
 363                         "out highp vec4 " << colorOutputName << ";\n"
 364                         "\n"
 365                         "void main (void)\n"
 366                         "{\n";
 367
 368         if (m_case == CASE_TRIANGLES)
 369                 buf <<  "       vec3 weights = vec3(pow(gl_TessCoord.x, 1.3), pow(gl_TessCoord.y, 1.3), pow(gl_TessCoord.z, 1.3));\n"
 370                                 "       vec3 cweights = gl_TessCoord;\n"
 371                                 "       gl_Position = vec4(weights.x * gl_in[0].gl_Position.xyz + weights.y * gl_in[1].gl_Position.xyz + weights.z * gl_in[2].gl_Position.xyz, 1.0);\n"
 372                                 "       " << colorOutputName << " = cweights.x * v_patch_color[0] + cweights.y * v_patch_color[1] + cweights.z * v_patch_color[2];\n";
 373         else if (m_case == CASE_QUADS || m_case == CASE_ISOLINES)
 374                 buf <<  "       vec2 normalizedCoord = (gl_TessCoord.xy * 2.0 - vec2(1.0));\n"
 375                                 "       vec2 normalizedWeights = normalizedCoord * (vec2(1.0) - 0.3 * cos(normalizedCoord.yx * 1.57));\n"
 376                                 "       vec2 weights = normalizedWeights * 0.5 + vec2(0.5);\n"
 377                                 "       vec2 cweights = gl_TessCoord.xy;\n"
 378                                 "       gl_Position = mix(mix(gl_in[0].gl_Position, gl_in[1].gl_Position, weights.y), mix(gl_in[2].gl_Position, gl_in[3].gl_Position, weights.y), weights.x);\n"
 379                                 "       " << colorOutputName << " = mix(mix(v_patch_color[0], v_patch_color[1], cweights.y), mix(v_patch_color[2], v_patch_color[3], cweights.y), cweights.x);\n";
 380         else
 381                 DE_ASSERT(false);
 382
 383         buf <<  "}\n";
 384
 385         return buf.str();
 386 }
 387
 388 std::string IdentityGeometryShaderCase::getGeometrySource (void) const
 389 {
 390         const char* const       geometryInputPrimitive                  = (m_case == CASE_ISOLINES) ? ("lines") : ("triangles");
 391         const char* const       geometryOutputPrimitive                 = (m_case == CASE_ISOLINES) ? ("line_strip") : ("triangle_strip");
 392         const int                       numEmitVertices                                 = (m_case == CASE_ISOLINES) ? (2) : (3);
 393         std::ostringstream      buf;
 394
 395         buf <<  "#version 310 es\n"
 396                         "#extension GL_EXT_geometry_shader : require\n"
 397                         "layout(" << geometryInputPrimitive << ") in;\n"
 398                         "layout(" << geometryOutputPrimitive << ", max_vertices=" << numEmitVertices <<") out;\n"
 399                         "\n"
 400                         "in highp vec4 v_evaluated_color[];\n"
 401                         "out highp vec4 v_fragment_color;\n"
 402                         "\n"
 403                         "void main (void)\n"
 404                         "{\n"
 405                         "       for (int ndx = 0; ndx < gl_in.length(); ++ndx)\n"
 406                         "       {\n"
 407                         "               gl_Position = gl_in[ndx].gl_Position;\n"
 408                         "               v_fragment_color = v_evaluated_color[ndx];\n"
 409                         "               EmitVertex();\n"
 410                         "       }\n"
 411                         "}\n";
 412
 413         return buf.str();
 414 }
 415
 416 class IdentityTessellationShaderCase : public IdentityShaderCase
 417 {
 418 public:
 419         enum CaseType
 420         {
 421                 CASE_TRIANGLES = 0,
 422                 CASE_ISOLINES,
 423         };
 424
 425                                         IdentityTessellationShaderCase          (Context& context, const char* name, const char* description, CaseType caseType);
 426                                         ~IdentityTessellationShaderCase         (void);
 427
 428 private:
 429         void                    init                                                            (void);
 430         void                    deinit                                                          (void);
 431         IterateResult   iterate                                                         (void);
 432
 433         std::string             getTessellationControlSource            (void) const;
 434         std::string             getTessellationEvaluationSource         (void) const;
 435         std::string             getGeometrySource                                       (bool tessellationActive) const;
 436
 437         enum
 438         {
 439                 RENDER_SIZE = 256,
 440         };
 441
 442         const CaseType  m_case;
 443         deUint32                m_dataBuffer;
 444 };
 445
 446 IdentityTessellationShaderCase::IdentityTessellationShaderCase (Context& context, const char* name, const char* description, CaseType caseType)
 447         : IdentityShaderCase    (context, name, description)
 448         , m_case                                (caseType)
 449         , m_dataBuffer                  (0)
 450 {
 451 }
 452
 453 IdentityTessellationShaderCase::~IdentityTessellationShaderCase (void)
 454 {
 455         deinit();
 456 }
 457
 458 void IdentityTessellationShaderCase::init (void)
 459 {
 460         // Requirements
 461
 462         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
 463                 !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 464                 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
 465
 466         if (m_context.getRenderTarget().getWidth() < RENDER_SIZE ||
 467                 m_context.getRenderTarget().getHeight() < RENDER_SIZE)
 468                 throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" + de::toString<int>(RENDER_SIZE) + " or larger render target.");
 469
 470         // Log
 471
 472         m_testCtx.getLog()
 473                 << tcu::TestLog::Message
 474                 << "Testing geometry shading shader program output does not change when a passthrough tessellation shader is attached.\n"
 475                 << "Rendering two images, first with and second without a tessellation shader. Expecting similar results.\n"
 476                 << "Using additive blending to detect overlap.\n"
 477                 << tcu::TestLog::EndMessage;
 478
 479         // Resources
 480
 481         {
 482                 static const tcu::Vec4  pointData[]     =
 483                 {
 484                         tcu::Vec4( -0.4f,  0.4f, 0.0f, 1.0f ),
 485                         tcu::Vec4(  0.0f, -0.5f, 0.0f, 1.0f ),
 486                         tcu::Vec4(  0.4f,  0.4f, 0.0f, 1.0f ),
 487                 };
 488                 const glw::Functions&   gl                      = m_context.getRenderContext().getFunctions();
 489
 490                 gl.genBuffers(1, &m_dataBuffer);
 491                 gl.bindBuffer(GL_ARRAY_BUFFER, m_dataBuffer);
 492                 gl.bufferData(GL_ARRAY_BUFFER, sizeof(pointData), pointData, GL_STATIC_DRAW);
 493                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
 494         }
 495 }
 496
 497 void IdentityTessellationShaderCase::deinit (void)
 498 {
 499         if (m_dataBuffer)
 500         {
 501                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_dataBuffer);
 502                 m_dataBuffer = 0;
 503         }
 504 }
 505
 506 IdentityTessellationShaderCase::IterateResult IdentityTessellationShaderCase::iterate (void)
 507 {
 508         const glw::Functions&   gl                                                      = m_context.getRenderContext().getFunctions();
 509         tcu::Surface                    resultWithTessellation          (RENDER_SIZE, RENDER_SIZE);
 510         tcu::Surface                    resultWithoutTessellation       (RENDER_SIZE, RENDER_SIZE);
 511         const int                               numPrimitiveVertices            = (m_case == CASE_TRIANGLES) ? (3) : (2);
 512
 513         const struct
 514         {
 515                 const char*                             name;
 516                 const char*                             description;
 517                 bool                                    containsTessellationShaders;
 518                 tcu::PixelBufferAccess  surfaceAccess;
 519         } renderTargets[] =
 520         {
 521                 { "RenderWithTessellationShader",               "Render with tessellation shader",              true,   resultWithTessellation.getAccess()              },
 522                 { "RenderWithoutTessellationShader",    "Render without tessellation shader",   false,  resultWithoutTessellation.getAccess()   },
 523         };
 524
 525         gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
 526         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
 527         GLU_EXPECT_NO_ERROR(gl.getError(), "set viewport");
 528
 529         gl.enable(GL_BLEND);
 530         gl.blendFunc(GL_SRC_ALPHA, GL_ONE);
 531         gl.blendEquation(GL_FUNC_ADD);
 532         GLU_EXPECT_NO_ERROR(gl.getError(), "set blend");
 533
 534         // render with and without tessellation shader
 535         for (int renderNdx = 0; renderNdx < DE_LENGTH_OF_ARRAY(renderTargets); ++renderNdx)
 536         {
 537                 const tcu::ScopedLogSection     section (m_testCtx.getLog(), renderTargets[renderNdx].name, renderTargets[renderNdx].description);
 538                 glu::ProgramSources                     sources;
 539
 540                 sources << glu::VertexSource(getVertexSource())
 541                                 << glu::FragmentSource(getFragmentSource())
 542                                 << glu::GeometrySource(getGeometrySource(renderTargets[renderNdx].containsTessellationShaders));
 543
 544                 if (renderTargets[renderNdx].containsTessellationShaders)
 545                         sources << glu::TessellationControlSource(getTessellationControlSource())
 546                                         << glu::TessellationEvaluationSource(getTessellationEvaluationSource());
 547
 548                 {
 549                         const glu::ShaderProgram        program                                 (m_context.getRenderContext(), sources);
 550                         const glu::VertexArray          vao                                             (m_context.getRenderContext());
 551                         const int                                       posLocation                             = gl.getAttribLocation(program.getProgram(), "a_position");
 552
 553                         m_testCtx.getLog() << program;
 554
 555                         if (!program.isOk())
 556                                 throw tcu::TestError("could not build program");
 557                         if (posLocation == -1)
 558                                 throw tcu::TestError("a_position location was -1");
 559
 560                         gl.bindVertexArray(*vao);
 561                         gl.bindBuffer(GL_ARRAY_BUFFER, m_dataBuffer);
 562                         gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
 563                         gl.enableVertexAttribArray(posLocation);
 564                         GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
 565
 566                         gl.useProgram(program.getProgram());
 567                         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
 568
 569                         gl.clear(GL_COLOR_BUFFER_BIT);
 570                         GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
 571
 572                         if (renderTargets[renderNdx].containsTessellationShaders)
 573                         {
 574                                 gl.patchParameteri(GL_PATCH_VERTICES, numPrimitiveVertices);
 575                                 GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
 576
 577                                 gl.drawArrays(GL_PATCHES, 0, numPrimitiveVertices);
 578                                 GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
 579                         }
 580                         else
 581                         {
 582                                 gl.drawArrays((m_case == CASE_TRIANGLES) ? (GL_TRIANGLES) : (GL_LINES), 0, numPrimitiveVertices);
 583                                 GLU_EXPECT_NO_ERROR(gl.getError(), "draw primitives");
 584                         }
 585
 586                         glu::readPixels(m_context.getRenderContext(), 0, 0, renderTargets[renderNdx].surfaceAccess);
 587                 }
 588         }
 589
 590         // compare
 591         {
 592                 bool imageOk;
 593
 594                 if (m_context.getRenderTarget().getNumSamples() > 1)
 595                         imageOk = tcu::fuzzyCompare(m_testCtx.getLog(),
 596                                                                                 "ImageCompare",
 597                                                                                 "Image comparison",
 598                                                                                 resultWithoutTessellation.getAccess(),
 599                                                                                 resultWithTessellation.getAccess(),
 600                                                                                 0.03f,
 601                                                                                 tcu::COMPARE_LOG_RESULT);
 602                 else
 603                         imageOk = tcu::intThresholdPositionDeviationCompare(m_testCtx.getLog(),
 604                                                                                                                                 "ImageCompare",
 605                                                                                                                                 "Image comparison",
 606                                                                                                                                 resultWithoutTessellation.getAccess(),
 607                                                                                                                                 resultWithTessellation.getAccess(),
 608                                                                                                                                 tcu::UVec4(8, 8, 8, 255),                               //!< threshold
 609                                                                                                                                 tcu::IVec3(1, 1, 0),                                    //!< 3x3 search kernel
 610                                                                                                                                 true,                                                                   //!< fragments may end up over the viewport, just ignore them
 611                                                                                                                                 tcu::COMPARE_LOG_RESULT);
 612
 613                 if (imageOk)
 614                         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 615                 else
 616                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
 617         }
 618
 619         return STOP;
 620 }
 621
 622 std::string IdentityTessellationShaderCase::getTessellationControlSource (void) const
 623 {
 624         std::ostringstream buf;
 625
 626         buf <<  "#version 310 es\n"
 627                         "#extension GL_EXT_tessellation_shader : require\n"
 628                         "layout(vertices = " << ((m_case == CASE_TRIANGLES) ? (3) : (2)) << ") out;\n"
 629                         "\n"
 630                         "in highp vec4 v_vertex_color[];\n"
 631                         "out highp vec4 v_control_color[];\n"
 632                         "\n"
 633                         "void main (void)\n"
 634                         "{\n"
 635                         "       gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
 636                         "       v_control_color[gl_InvocationID] = v_vertex_color[gl_InvocationID];\n"
 637                         "\n";
 638
 639         if (m_case == CASE_TRIANGLES)
 640                 buf <<  "       gl_TessLevelOuter[0] = 1.0;\n"
 641                                 "       gl_TessLevelOuter[1] = 1.0;\n"
 642                                 "       gl_TessLevelOuter[2] = 1.0;\n"
 643                                 "       gl_TessLevelInner[0] = 1.0;\n";
 644         else if (m_case == CASE_ISOLINES)
 645                 buf <<  "       gl_TessLevelOuter[0] = 1.0;\n"
 646                                 "       gl_TessLevelOuter[1] = 1.0;\n";
 647         else
 648                 DE_ASSERT(false);
 649
 650         buf <<  "}\n";
 651
 652         return buf.str();
 653 }
 654
 655 std::string IdentityTessellationShaderCase::getTessellationEvaluationSource (void) const
 656 {
 657         std::ostringstream buf;
 658
 659         buf <<  "#version 310 es\n"
 660                         "#extension GL_EXT_tessellation_shader : require\n"
 661                         "layout("
 662                                 << ((m_case == CASE_TRIANGLES) ? ("triangles") : ("isolines"))
 663                                 << ") in;\n"
 664                         "\n"
 665                         "in highp vec4 v_control_color[];\n"
 666                         "out highp vec4 v_evaluated_color;\n"
 667                         "\n"
 668                         "void main (void)\n"
 669                         "{\n";
 670
 671         if (m_case == CASE_TRIANGLES)
 672                 buf <<  "       gl_Position = gl_TessCoord.x * gl_in[0].gl_Position + gl_TessCoord.y * gl_in[1].gl_Position + gl_TessCoord.z * gl_in[2].gl_Position;\n"
 673                                 "       v_evaluated_color = gl_TessCoord.x * v_control_color[0] + gl_TessCoord.y * v_control_color[1] + gl_TessCoord.z * v_control_color[2];\n";
 674         else if (m_case == CASE_ISOLINES)
 675                 buf <<  "       gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, gl_TessCoord.x);\n"
 676                                 "       v_evaluated_color = mix(v_control_color[0], v_control_color[1], gl_TessCoord.x);\n";
 677         else
 678                 DE_ASSERT(false);
 679
 680         buf <<  "}\n";
 681
 682         return buf.str();
 683 }
 684
 685 std::string IdentityTessellationShaderCase::getGeometrySource (bool tessellationActive) const
 686 {
 687         const char* const       colorSourceName                 = (tessellationActive) ? ("v_evaluated_color") : ("v_vertex_color");
 688         const char* const       geometryInputPrimitive  = (m_case == CASE_ISOLINES) ? ("lines") : ("triangles");
 689         const char* const       geometryOutputPrimitive = (m_case == CASE_ISOLINES) ? ("line_strip") : ("triangle_strip");
 690         const int                       numEmitVertices                 = (m_case == CASE_ISOLINES) ? (11) : (8);
 691         std::ostringstream      buf;
 692
 693         buf <<  "#version 310 es\n"
 694                         "#extension GL_EXT_geometry_shader : require\n"
 695                         "layout(" << geometryInputPrimitive << ") in;\n"
 696                         "layout(" << geometryOutputPrimitive << ", max_vertices=" << numEmitVertices <<") out;\n"
 697                         "\n"
 698                         "in highp vec4 " << colorSourceName << "[];\n"
 699                         "out highp vec4 v_fragment_color;\n"
 700                         "\n"
 701                         "void main (void)\n"
 702                         "{\n";
 703
 704         if (m_case == CASE_TRIANGLES)
 705         {
 706                 buf <<  "       vec4 centerPos = (gl_in[0].gl_Position + gl_in[1].gl_Position + gl_in[2].gl_Position) / 3.0f;\n"
 707                                 "\n"
 708                                 "       for (int ndx = 0; ndx < 4; ++ndx)\n"
 709                                 "       {\n"
 710                                 "               gl_Position = centerPos + (centerPos - gl_in[ndx % 3].gl_Position);\n"
 711                                 "               v_fragment_color = " << colorSourceName << "[ndx % 3];\n"
 712                                 "               EmitVertex();\n"
 713                                 "\n"
 714                                 "               gl_Position = centerPos + 0.7 * (centerPos - gl_in[ndx % 3].gl_Position);\n"
 715                                 "               v_fragment_color = " << colorSourceName << "[ndx % 3];\n"
 716                                 "               EmitVertex();\n"
 717                                 "       }\n";
 718
 719         }
 720         else if (m_case == CASE_ISOLINES)
 721         {
 722                 buf <<  "       vec4 mdir = vec4(gl_in[0].gl_Position.y - gl_in[1].gl_Position.y, gl_in[1].gl_Position.x - gl_in[0].gl_Position.x, 0.0, 0.0);\n"
 723                                 "       for (int i = 0; i <= 10; ++i)\n"
 724                                 "       {\n"
 725                                 "               float xweight = cos(float(i) / 10.0 * 6.28) * 0.5 + 0.5;\n"
 726                                 "               float mweight = sin(float(i) / 10.0 * 6.28) * 0.1 + 0.1;\n"
 727                                 "               gl_Position = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, xweight) + mweight * mdir;\n"
 728                                 "               v_fragment_color = mix(" << colorSourceName << "[0], " << colorSourceName << "[1], xweight);\n"
 729                                 "               EmitVertex();\n"
 730                                 "       }\n";
 731         }
 732         else
 733                 DE_ASSERT(false);
 734
 735         buf <<  "}\n";
 736
 737         return buf.str();
 738 }
 739
 740 class FeedbackPrimitiveTypeCase : public TestCase
 741 {
 742 public:
 743         enum TessellationOutputType
 744         {
 745                 TESSELLATION_OUT_TRIANGLES = 0,
 746                 TESSELLATION_OUT_QUADS,
 747                 TESSELLATION_OUT_ISOLINES,
 748
 749                 TESSELLATION_OUT_LAST
 750         };
 751         enum TessellationPointMode
 752         {
 753                 TESSELLATION_POINTMODE_OFF = 0,
 754                 TESSELLATION_POINTMODE_ON,
 755
 756                 TESSELLATION_POINTMODE_LAST
 757         };
 758         enum GeometryOutputType
 759         {
 760                 GEOMETRY_OUTPUT_POINTS = 0,
 761                 GEOMETRY_OUTPUT_LINES,
 762                 GEOMETRY_OUTPUT_TRIANGLES,
 763
 764                 GEOMETRY_OUTPUT_LAST
 765         };
 766
 767                                                                         FeedbackPrimitiveTypeCase                               (Context& context,
 768                                                                                                                                                          const char* name,
 769                                                                                                                                                          const char* description,
 770                                                                                                                                                          TessellationOutputType tessellationOutput,
 771                                                                                                                                                          TessellationPointMode tessellationPointMode,
 772                                                                                                                                                          GeometryOutputType geometryOutputType);
 773                                                                         ~FeedbackPrimitiveTypeCase                              (void);
 774
 775 private:
 776         void                                                    init                                                                    (void);
 777         void                                                    deinit                                                                  (void);
 778         IterateResult                                   iterate                                                                 (void);
 779
 780         void                                                    renderWithFeedback                                              (tcu::Surface& dst);
 781         void                                                    renderWithoutFeedback                                   (tcu::Surface& dst);
 782         void                                                    verifyFeedbackResults                                   (const std::vector<tcu::Vec4>& feedbackResult);
 783         void                                                    verifyRenderedImage                                             (const tcu::Surface& image, const std::vector<tcu::Vec4>& vertices);
 784
 785         void                                                    genTransformFeedback                                    (void);
 786         int                                                             getNumGeneratedElementsPerPrimitive             (void) const;
 787         int                                                             getNumGeneratedPrimitives                               (void) const;
 788         int                                                             getNumTessellatedPrimitives                             (void) const;
 789         int                                                             getGeometryAmplification                                (void) const;
 790
 791         const char*                                             getVertexSource                                                 (void) const;
 792         const char*                                             getFragmentSource                                               (void) const;
 793         std::string                                             getTessellationControlSource                    (void) const;
 794         std::string                                             getTessellationEvaluationSource                 (void) const;
 795         std::string                                             getGeometrySource                                               (void) const;
 796
 797         static const char*                              getTessellationOutputDescription                (TessellationOutputType tessellationOutput,
 798                                                                                                                                                          TessellationPointMode tessellationPointMode);
 799         static const char*                              getGeometryInputDescription                             (TessellationOutputType tessellationOutput,
 800                                                                                                                                                          TessellationPointMode tessellationPointMode);
 801         static const char*                              getGeometryOutputDescription                    (GeometryOutputType geometryOutput);
 802         glw::GLenum                                             getOutputPrimitiveGLType                                (void) const;
 803
 804         enum
 805         {
 806                 RENDER_SIZE = 128,
 807         };
 808
 809         const TessellationOutputType    m_tessellationOutput;
 810         const TessellationPointMode             m_tessellationPointMode;
 811         const GeometryOutputType                m_geometryOutputType;
 812
 813         glu::ShaderProgram*                             m_feedbackProgram;
 814         glu::ShaderProgram*                             m_nonFeedbackProgram;
 815         deUint32                                                m_patchBuffer;
 816         deUint32                                                m_feedbackID;
 817         deUint32                                                m_feedbackBuffer;
 818 };
 819
 820 FeedbackPrimitiveTypeCase::FeedbackPrimitiveTypeCase (Context& context,
 821                                                                           const char* name,
 822                                                                           const char* description,
 823                                                                           TessellationOutputType tessellationOutput,
 824                                                                           TessellationPointMode tessellationPointMode,
 825                                                                           GeometryOutputType geometryOutputType)
 826         : TestCase                                      (context, name, description)
 827         , m_tessellationOutput          (tessellationOutput)
 828         , m_tessellationPointMode       (tessellationPointMode)
 829         , m_geometryOutputType          (geometryOutputType)
 830         , m_feedbackProgram                     (DE_NULL)
 831         , m_nonFeedbackProgram          (DE_NULL)
 832         , m_patchBuffer                         (0)
 833         , m_feedbackID                          (0)
 834         , m_feedbackBuffer                      (0)
 835 {
 836         DE_ASSERT(tessellationOutput < TESSELLATION_OUT_LAST);
 837         DE_ASSERT(tessellationPointMode < TESSELLATION_POINTMODE_LAST);
 838         DE_ASSERT(geometryOutputType < GEOMETRY_OUTPUT_LAST);
 839 }
 840
 841 FeedbackPrimitiveTypeCase::~FeedbackPrimitiveTypeCase (void)
 842 {
 843         deinit();
 844 }
 845
 846 void FeedbackPrimitiveTypeCase::init (void)
 847 {
 848         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
 849
 850         // Requirements
 851
 852         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
 853                 !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
 854                 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
 855
 856         if (m_context.getRenderTarget().getWidth() < RENDER_SIZE ||
 857                 m_context.getRenderTarget().getHeight() < RENDER_SIZE)
 858                 throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" + de::toString<int>(RENDER_SIZE) + " or larger render target.");
 859
 860         // Log
 861
 862         m_testCtx.getLog()
 863                 << tcu::TestLog::Message
 864                 << "Testing "
 865                         << getTessellationOutputDescription(m_tessellationOutput, m_tessellationPointMode)
 866                         << "->"
 867                         << getGeometryInputDescription(m_tessellationOutput, m_tessellationPointMode)
 868                         << " primitive conversion with and without transform feedback.\n"
 869                 << "Sending a patch of 4 vertices (2x2 uniform grid) to tessellation control shader.\n"
 870                 << "Control shader emits a patch of 9 vertices (3x3 uniform grid).\n"
 871                 << "Setting outer tessellation level = 3, inner = 3.\n"
 872                 << "Primitive generator emits " << getTessellationOutputDescription(m_tessellationOutput, m_tessellationPointMode) << "\n"
 873                 << "Geometry shader transforms emitted primitives to " << getGeometryOutputDescription(m_geometryOutputType) << "\n"
 874                 << "Reading back vertex positions of generated primitives using transform feedback.\n"
 875                 << "Verifying rendered image and feedback vertices are consistent.\n"
 876                 << "Rendering scene again with identical shader program, but without setting feedback varying. Expecting similar output image."
 877                 << tcu::TestLog::EndMessage;
 878
 879         // Resources
 880
 881         {
 882                 static const tcu::Vec4 patchBufferData[4] =
 883                 {
 884                         tcu::Vec4( -0.9f, -0.9f, 0.0f, 1.0f ),
 885                         tcu::Vec4( -0.9f,  0.9f, 0.0f, 1.0f ),
 886                         tcu::Vec4(  0.9f, -0.9f, 0.0f, 1.0f ),
 887                         tcu::Vec4(  0.9f,  0.9f, 0.0f, 1.0f ),
 888                 };
 889
 890                 gl.genBuffers(1, &m_patchBuffer);
 891                 gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
 892                 gl.bufferData(GL_ARRAY_BUFFER, sizeof(patchBufferData), patchBufferData, GL_STATIC_DRAW);
 893                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen buffer");
 894         }
 895
 896         m_feedbackProgram = new glu::ShaderProgram(m_context.getRenderContext(),
 897                                                                                            glu::ProgramSources()
 898                                                                                                 << glu::VertexSource(getVertexSource())
 899                                                                                                 << glu::FragmentSource(getFragmentSource())
 900                                                                                                 << glu::TessellationControlSource(getTessellationControlSource())
 901                                                                                                 << glu::TessellationEvaluationSource(getTessellationEvaluationSource())
 902                                                                                                 << glu::GeometrySource(getGeometrySource())
 903                                                                                                 << glu::TransformFeedbackVarying("tf_someVertexPosition")
 904                                                                                                 << glu::TransformFeedbackMode(GL_INTERLEAVED_ATTRIBS));
 905         m_testCtx.getLog() << *m_feedbackProgram;
 906         if (!m_feedbackProgram->isOk())
 907                 throw tcu::TestError("failed to build program");
 908
 909         m_nonFeedbackProgram = new glu::ShaderProgram(m_context.getRenderContext(),
 910                                                                                                   glu::ProgramSources()
 911                                                                                                         << glu::VertexSource(getVertexSource())
 912                                                                                                         << glu::FragmentSource(getFragmentSource())
 913                                                                                                         << glu::TessellationControlSource(getTessellationControlSource())
 914                                                                                                         << glu::TessellationEvaluationSource(getTessellationEvaluationSource())
 915                                                                                                         << glu::GeometrySource(getGeometrySource()));
 916         if (!m_nonFeedbackProgram->isOk())
 917         {
 918                 m_testCtx.getLog() << *m_nonFeedbackProgram;
 919                 throw tcu::TestError("failed to build program");
 920         }
 921
 922         genTransformFeedback();
 923 }
 924
 925 void FeedbackPrimitiveTypeCase::deinit (void)
 926 {
 927         if (m_patchBuffer)
 928         {
 929                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_patchBuffer);
 930                 m_patchBuffer = 0;
 931         }
 932
 933         if (m_feedbackBuffer)
 934         {
 935                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_feedbackBuffer);
 936                 m_feedbackBuffer = 0;
 937         }
 938
 939         if (m_feedbackID)
 940         {
 941                 m_context.getRenderContext().getFunctions().deleteTransformFeedbacks(1, &m_feedbackID);
 942                 m_feedbackID = 0;
 943         }
 944
 945         if (m_feedbackProgram)
 946         {
 947                 delete m_feedbackProgram;
 948                 m_feedbackProgram = DE_NULL;
 949         }
 950
 951         if (m_nonFeedbackProgram)
 952         {
 953                 delete m_nonFeedbackProgram;
 954                 m_nonFeedbackProgram = DE_NULL;
 955         }
 956 }
 957
 958 FeedbackPrimitiveTypeCase::IterateResult FeedbackPrimitiveTypeCase::iterate (void)
 959 {
 960         tcu::Surface feedbackResult             (RENDER_SIZE, RENDER_SIZE);
 961         tcu::Surface nonFeedbackResult  (RENDER_SIZE, RENDER_SIZE);
 962
 963         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
 964
 965         // render with and without XFB
 966         renderWithFeedback(feedbackResult);
 967         renderWithoutFeedback(nonFeedbackResult);
 968
 969         // compare
 970         {
 971                 bool imageOk;
 972
 973                 m_testCtx.getLog() << tcu::TestLog::Message << "Comparing the image rendered with no transform feedback against the image rendered with enabled transform feedback." << tcu::TestLog::EndMessage;
 974
 975                 if (m_context.getRenderTarget().getNumSamples() > 1)
 976                         imageOk = tcu::fuzzyCompare(m_testCtx.getLog(),
 977                                                                                 "ImageCompare",
 978                                                                                 "Image comparison",
 979                                                                                 feedbackResult.getAccess(),
 980                                                                                 nonFeedbackResult.getAccess(),
 981                                                                                 0.03f,
 982                                                                                 tcu::COMPARE_LOG_RESULT);
 983                 else
 984                         imageOk = tcu::intThresholdPositionDeviationCompare(m_testCtx.getLog(),
 985                                                                                                                                 "ImageCompare",
 986                                                                                                                                 "Image comparison",
 987                                                                                                                                 feedbackResult.getAccess(),
 988                                                                                                                                 nonFeedbackResult.getAccess(),
 989                                                                                                                                 tcu::UVec4(8, 8, 8, 255),                                               //!< threshold
 990                                                                                                                                 tcu::IVec3(1, 1, 0),                                                    //!< 3x3 search kernel
 991                                                                                                                                 true,                                                                                   //!< fragments may end up over the viewport, just ignore them
 992                                                                                                                                 tcu::COMPARE_LOG_RESULT);
 993
 994                 if (!imageOk)
 995                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image comparison failed");
 996         }
 997
 998         return STOP;
 999 }
1000
1001 void FeedbackPrimitiveTypeCase::renderWithFeedback(tcu::Surface& dst)
1002 {
1003         const glw::Functions&                   gl                                                      = m_context.getRenderContext().getFunctions();
1004         const glu::VertexArray                  vao                                                     (m_context.getRenderContext());
1005         const glu::Query                                primitivesGeneratedQuery        (m_context.getRenderContext());
1006         const int                                               posLocation                                     = gl.getAttribLocation(m_feedbackProgram->getProgram(), "a_position");
1007         const glw::GLenum                               feedbackPrimitiveMode           = getOutputPrimitiveGLType();
1008
1009         if (posLocation == -1)
1010                 throw tcu::TestError("a_position was -1");
1011
1012         m_testCtx.getLog() << tcu::TestLog::Message << "Rendering with transform feedback" << tcu::TestLog::EndMessage;
1013
1014         gl.viewport(0, 0, dst.getWidth(), dst.getHeight());
1015         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
1016         gl.clear(GL_COLOR_BUFFER_BIT);
1017         GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
1018
1019         gl.bindVertexArray(*vao);
1020         gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
1021         gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
1022         gl.enableVertexAttribArray(posLocation);
1023         GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
1024
1025         gl.useProgram(m_feedbackProgram->getProgram());
1026         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
1027
1028         gl.patchParameteri(GL_PATCH_VERTICES, 4);
1029         GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
1030
1031         gl.beginQuery(GL_PRIMITIVES_GENERATED, *primitivesGeneratedQuery);
1032         GLU_EXPECT_NO_ERROR(gl.getError(), "begin GL_PRIMITIVES_GENERATED query");
1033
1034         m_testCtx.getLog() << tcu::TestLog::Message << "Begin transform feedback with mode " << glu::getPrimitiveTypeStr(feedbackPrimitiveMode) << tcu::TestLog::EndMessage;
1035
1036         gl.beginTransformFeedback(feedbackPrimitiveMode);
1037         GLU_EXPECT_NO_ERROR(gl.getError(), "begin xfb");
1038
1039         m_testCtx.getLog() << tcu::TestLog::Message << "Calling drawArrays with mode GL_PATCHES" << tcu::TestLog::EndMessage;
1040
1041         gl.drawArrays(GL_PATCHES, 0, 4);
1042         GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
1043
1044         gl.endTransformFeedback();
1045         GLU_EXPECT_NO_ERROR(gl.getError(), "end xfb");
1046
1047         gl.endQuery(GL_PRIMITIVES_GENERATED);
1048         GLU_EXPECT_NO_ERROR(gl.getError(), "end GL_PRIMITIVES_GENERATED query");
1049
1050         glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
1051         GLU_EXPECT_NO_ERROR(gl.getError(), "readPixels");
1052
1053         // verify GL_PRIMITIVES_GENERATED
1054         {
1055                 glw::GLuint primitivesGeneratedResult = 0;
1056                 gl.getQueryObjectuiv(*primitivesGeneratedQuery, GL_QUERY_RESULT, &primitivesGeneratedResult);
1057                 GLU_EXPECT_NO_ERROR(gl.getError(), "get GL_PRIMITIVES_GENERATED value");
1058
1059                 m_testCtx.getLog() << tcu::TestLog::Message << "Verifying GL_PRIMITIVES_GENERATED, expecting " << getNumGeneratedPrimitives() << tcu::TestLog::EndMessage;
1060
1061                 if ((int)primitivesGeneratedResult != getNumGeneratedPrimitives())
1062                 {
1063                         m_testCtx.getLog() << tcu::TestLog::Message << "Error, GL_PRIMITIVES_GENERATED was " << primitivesGeneratedResult << tcu::TestLog::EndMessage;
1064                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Got unexpected GL_PRIMITIVES_GENERATED");
1065                 }
1066                 else
1067                         m_testCtx.getLog() << tcu::TestLog::Message << "GL_PRIMITIVES_GENERATED valid." << tcu::TestLog::EndMessage;
1068         }
1069
1070         // feedback
1071         {
1072                 std::vector<tcu::Vec4>  feedbackResults         (getNumGeneratedElementsPerPrimitive() * getNumGeneratedPrimitives());
1073                 const void*                             mappedPtr                       = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, (glw::GLsizeiptr)(feedbackResults.size() * sizeof(tcu::Vec4)), GL_MAP_READ_BIT);
1074                 glw::GLboolean                  unmapResult;
1075
1076                 GLU_EXPECT_NO_ERROR(gl.getError(), "mapBufferRange");
1077
1078                 m_testCtx.getLog() << tcu::TestLog::Message << "Reading transform feedback buffer." << tcu::TestLog::EndMessage;
1079                 if (!mappedPtr)
1080                         throw tcu::TestError("mapBufferRange returned null");
1081
1082                 deMemcpy(feedbackResults[0].getPtr(), mappedPtr, (int)(feedbackResults.size() * sizeof(tcu::Vec4)));
1083
1084                 unmapResult = gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER);
1085                 GLU_EXPECT_NO_ERROR(gl.getError(), "unmapBuffer");
1086
1087                 if (unmapResult != GL_TRUE)
1088                         throw tcu::TestError("unmapBuffer failed, did not return true");
1089
1090                 // verify transform results
1091                 verifyFeedbackResults(feedbackResults);
1092
1093                 // verify feedback results are consistent with rendered image
1094                 verifyRenderedImage(dst, feedbackResults);
1095         }
1096 }
1097
1098 void FeedbackPrimitiveTypeCase::renderWithoutFeedback (tcu::Surface& dst)
1099 {
1100         const glw::Functions&                   gl                                                      = m_context.getRenderContext().getFunctions();
1101         const glu::VertexArray                  vao                                                     (m_context.getRenderContext());
1102         const int                                               posLocation                                     = gl.getAttribLocation(m_nonFeedbackProgram->getProgram(), "a_position");
1103
1104         if (posLocation == -1)
1105                 throw tcu::TestError("a_position was -1");
1106
1107         m_testCtx.getLog() << tcu::TestLog::Message << "Rendering without transform feedback" << tcu::TestLog::EndMessage;
1108
1109         gl.viewport(0, 0, dst.getWidth(), dst.getHeight());
1110         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
1111         gl.clear(GL_COLOR_BUFFER_BIT);
1112         GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
1113
1114         gl.bindVertexArray(*vao);
1115         gl.bindBuffer(GL_ARRAY_BUFFER, m_patchBuffer);
1116         gl.vertexAttribPointer(posLocation, 4, GL_FLOAT, GL_FALSE, 0, DE_NULL);
1117         gl.enableVertexAttribArray(posLocation);
1118         GLU_EXPECT_NO_ERROR(gl.getError(), "setup attribs");
1119
1120         gl.useProgram(m_nonFeedbackProgram->getProgram());
1121         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
1122
1123         gl.patchParameteri(GL_PATCH_VERTICES, 4);
1124         GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
1125
1126         m_testCtx.getLog() << tcu::TestLog::Message << "Calling drawArrays with mode GL_PATCHES" << tcu::TestLog::EndMessage;
1127
1128         gl.drawArrays(GL_PATCHES, 0, 4);
1129         GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
1130
1131         glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
1132         GLU_EXPECT_NO_ERROR(gl.getError(), "readPixels");
1133 }
1134
1135 void FeedbackPrimitiveTypeCase::verifyFeedbackResults (const std::vector<tcu::Vec4>& feedbackResult)
1136 {
1137         const int       geometryAmplification   = getGeometryAmplification();
1138         const int       elementsPerPrimitive    = getNumGeneratedElementsPerPrimitive();
1139         const int       errorFloodThreshold             = 8;
1140         int                     readNdx                                 = 0;
1141         int                     numErrors                               = 0;
1142
1143         m_testCtx.getLog() << tcu::TestLog::Message << "Verifying feedback results." << tcu::TestLog::EndMessage;
1144
1145         for (int tessellatedPrimitiveNdx = 0; tessellatedPrimitiveNdx < getNumTessellatedPrimitives(); ++tessellatedPrimitiveNdx)
1146         {
1147                 const tcu::Vec4 primitiveVertex = feedbackResult[readNdx];
1148
1149                 // check the generated vertices are in the proper range (range: -0.4 <-> 0.4)
1150                 {
1151                         const float     equalThreshold  =       1.0e-6f;
1152                         const bool      centroidOk              =       (primitiveVertex.x() >= -0.4f - equalThreshold) &&
1153                                                                                         (primitiveVertex.x() <=  0.4f + equalThreshold) &&
1154                                                                                         (primitiveVertex.y() >= -0.4f - equalThreshold) &&
1155                                                                                         (primitiveVertex.y() <=  0.4f + equalThreshold) &&
1156                                                                                         (de::abs(primitiveVertex.z()) < equalThreshold) &&
1157                                                                                         (de::abs(primitiveVertex.w() - 1.0f) < equalThreshold);
1158
1159                         if (!centroidOk && numErrors++ < errorFloodThreshold)
1160                         {
1161                                 m_testCtx.getLog()
1162                                         << tcu::TestLog::Message
1163                                         << "Element at index " << (readNdx) << " (tessellation invocation " << tessellatedPrimitiveNdx << ")\n"
1164                                         << "\texpected vertex in range: ( [-0.4, 0.4], [-0.4, 0.4], 0.0, 1.0 )\n"
1165                                         << "\tgot: " << primitiveVertex
1166                                         << tcu::TestLog::EndMessage;
1167
1168                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid feedback output");
1169
1170                                 ++readNdx;
1171                                 continue;
1172                         }
1173                 }
1174
1175                 // check all other primitives generated from this tessellated primitive have the same feedback value
1176                 for (int generatedPrimitiveNdx = 0; generatedPrimitiveNdx < geometryAmplification; ++generatedPrimitiveNdx)
1177                 for (int primitiveVertexNdx = 0; primitiveVertexNdx < elementsPerPrimitive; ++primitiveVertexNdx)
1178                 {
1179                         const tcu::Vec4 generatedElementVertex  = feedbackResult[readNdx];
1180                         const tcu::Vec4 equalThreshold                  (1.0e-6f);
1181
1182                         if (tcu::boolAny(tcu::greaterThan(tcu::abs(primitiveVertex - generatedElementVertex), equalThreshold)))
1183                         {
1184                                 if (numErrors++ < errorFloodThreshold)
1185                                 {
1186                                         m_testCtx.getLog()
1187                                                 << tcu::TestLog::Message
1188                                                 << "Element at index " << (readNdx) << " (tessellation invocation " << tessellatedPrimitiveNdx << ", geometry primitive " << generatedPrimitiveNdx << ", emitted vertex " << primitiveVertexNdx << "):\n"
1189                                                 << "\tfeedback result was not contant over whole primitive.\n"
1190                                                 << "\tfirst emitted value: " << primitiveVertex << "\n"
1191                                                 << "\tcurrent emitted value:" << generatedElementVertex << "\n"
1192                                                 << tcu::TestLog::EndMessage;
1193                                 }
1194
1195                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got multiple different feedback values for a single primitive");
1196                         }
1197
1198                         readNdx++;
1199                 }
1200         }
1201
1202         if (numErrors > errorFloodThreshold)
1203                 m_testCtx.getLog() << tcu::TestLog::Message << "Omitted " << (numErrors - errorFloodThreshold) << " error(s)." << tcu::TestLog::EndMessage;
1204 }
1205
1206 static bool feedbackResultCompare (const tcu::Vec4& a, const tcu::Vec4& b)
1207 {
1208         if (a.x() < b.x())
1209                 return true;
1210         if (a.x() > b.x())
1211                 return false;
1212
1213         return a.y() < b.y();
1214 }
1215
1216 void FeedbackPrimitiveTypeCase::verifyRenderedImage (const tcu::Surface& image, const std::vector<tcu::Vec4>& tfVertices)
1217 {
1218         std::vector<tcu::Vec4> vertices;
1219
1220         m_testCtx.getLog() << tcu::TestLog::Message << "Comparing result image against feedback results." << tcu::TestLog::EndMessage;
1221
1222         // Check only unique vertices
1223         std::unique_copy(tfVertices.begin(), tfVertices.end(), std::back_insert_iterator<std::vector<tcu::Vec4> >(vertices));
1224         std::sort(vertices.begin(), vertices.end(), feedbackResultCompare);
1225         vertices.erase(std::unique(vertices.begin(), vertices.end()), vertices.end());
1226
1227         // Verifying vertices recorded with feedback actually ended up on the result image
1228         for (int ndx = 0; ndx < (int)vertices.size(); ++ndx)
1229         {
1230                 // Rasterization (of lines) may deviate by one pixel. In addition to that, allow minimal errors in rasterized position vs. feedback result.
1231                 // This minimal error could result in a difference in rounding => allow one additional pixel in deviation
1232
1233                 const int                       rasterDeviation = 2;
1234                 const tcu::IVec2        rasterPos               ((int)deFloatRound((vertices[ndx].x() * 0.5f + 0.5f) * image.getWidth()), (int)deFloatRound((vertices[ndx].y() * 0.5f + 0.5f) * image.getHeight()));
1235
1236                 // Find produced rasterization results
1237                 bool                            found                   = false;
1238
1239                 for (int dy = -rasterDeviation; dy <= rasterDeviation && !found; ++dy)
1240                 for (int dx = -rasterDeviation; dx <= rasterDeviation && !found; ++dx)
1241                 {
1242                         // Raster result could end up outside the viewport
1243                         if (rasterPos.x() + dx < 0 || rasterPos.x() + dx >= image.getWidth() ||
1244                                 rasterPos.y() + dy < 0 || rasterPos.y() + dy >= image.getHeight())
1245                                 found = true;
1246                         else
1247                         {
1248                                 const tcu::RGBA result = image.getPixel(rasterPos.x() + dx, rasterPos.y() + dy);
1249
1250                                 if(!isBlack(result))
1251                                         found = true;
1252                         }
1253                 }
1254
1255                 if (!found)
1256                 {
1257                         m_testCtx.getLog()
1258                                 << tcu::TestLog::Message
1259                                 << "Vertex " << vertices[ndx] << "\n"
1260                                 << "\tCould not find rasterization output for vertex.\n"
1261                                 << "\tExpected non-black pixels near " << rasterPos
1262                                 << tcu::TestLog::EndMessage;
1263
1264                         m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "invalid result image");
1265                 }
1266         }
1267 }
1268
1269 void FeedbackPrimitiveTypeCase::genTransformFeedback (void)
1270 {
1271         const glw::Functions&                   gl                                              = m_context.getRenderContext().getFunctions();
1272         const int                                               elementsPerPrimitive    = getNumGeneratedElementsPerPrimitive();
1273         const int                                               feedbackPrimitives              = getNumGeneratedPrimitives();
1274         const int                                               feedbackElements                = elementsPerPrimitive * feedbackPrimitives;
1275         const std::vector<tcu::Vec4>    initialBuffer                   (feedbackElements, tcu::Vec4(-1.0f, -1.0f, -1.0f, -1.0f));
1276
1277         gl.genTransformFeedbacks(1, &m_feedbackID);
1278         gl.bindTransformFeedback(GL_TRANSFORM_FEEDBACK, m_feedbackID);
1279         GLU_EXPECT_NO_ERROR(gl.getError(), "gen transform feedback");
1280
1281         gl.genBuffers(1, &m_feedbackBuffer);
1282         gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_feedbackBuffer);
1283         gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, sizeof(tcu::Vec4) * initialBuffer.size(), initialBuffer[0].getPtr(), GL_STATIC_COPY);
1284         GLU_EXPECT_NO_ERROR(gl.getError(), "gen feedback buffer");
1285
1286         gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_feedbackBuffer);
1287         GLU_EXPECT_NO_ERROR(gl.getError(), "bind feedback buffer");
1288 }
1289
1290 static int getTriangleNumOutputPrimitives (int tessellationLevel)
1291 {
1292         if (tessellationLevel == 1)
1293                 return 1;
1294         else if (tessellationLevel == 2)
1295                 return 6;
1296         else
1297                 return 3 * (2 + 2 * (tessellationLevel - 2)) + getTriangleNumOutputPrimitives(tessellationLevel - 2);
1298 }
1299
1300 static int getTriangleNumOutputPrimitivesPoints (int tessellationLevel)
1301 {
1302         if (tessellationLevel == 0)
1303                 return 1;
1304         else if (tessellationLevel == 1)
1305                 return 3;
1306         else
1307                 return 3 + 3 * (tessellationLevel - 1) + getTriangleNumOutputPrimitivesPoints(tessellationLevel - 2);
1308 }
1309
1310 int FeedbackPrimitiveTypeCase::getNumGeneratedElementsPerPrimitive (void) const
1311 {
1312         if (m_geometryOutputType == GEOMETRY_OUTPUT_TRIANGLES)
1313                 return 3;
1314         else if (m_geometryOutputType == GEOMETRY_OUTPUT_LINES)
1315                 return 2;
1316         else if (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS)
1317                 return 1;
1318         else
1319         {
1320                 DE_ASSERT(false);
1321                 return -1;
1322         }
1323 }
1324
1325 int FeedbackPrimitiveTypeCase::getNumGeneratedPrimitives (void) const
1326 {
1327         return getNumTessellatedPrimitives() * getGeometryAmplification();
1328 }
1329
1330 int FeedbackPrimitiveTypeCase::getNumTessellatedPrimitives (void) const
1331 {
1332         const int tessellationLevel = 3;
1333
1334         if (m_tessellationPointMode == TESSELLATION_POINTMODE_OFF)
1335         {
1336                 if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
1337                         return getTriangleNumOutputPrimitives(tessellationLevel);
1338                 else if (m_tessellationOutput == TESSELLATION_OUT_QUADS)
1339                         return tessellationLevel * tessellationLevel * 2; // tessellated as triangles
1340                 else if (m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
1341                         return tessellationLevel * tessellationLevel;
1342         }
1343         else if (m_tessellationPointMode == TESSELLATION_POINTMODE_ON)
1344         {
1345                 if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
1346                         return getTriangleNumOutputPrimitivesPoints(tessellationLevel);
1347                 else if (m_tessellationOutput == TESSELLATION_OUT_QUADS)
1348                         return (tessellationLevel + 1) * (tessellationLevel + 1);
1349                 else if (m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
1350                         return tessellationLevel * (tessellationLevel + 1);
1351         }
1352
1353         DE_ASSERT(false);
1354         return -1;
1355 }
1356
1357 int FeedbackPrimitiveTypeCase::getGeometryAmplification (void) const
1358 {
1359         const int outputAmplification   = (m_geometryOutputType == GEOMETRY_OUTPUT_LINES) ? (2) : (1);
1360         const int numInputVertices              = (m_tessellationPointMode) ? (1) : (m_tessellationOutput == TESSELLATION_OUT_ISOLINES) ? (2) : (3);
1361
1362         return outputAmplification * numInputVertices;
1363 }
1364
1365 glw::GLenum FeedbackPrimitiveTypeCase::getOutputPrimitiveGLType (void) const
1366 {
1367         if (m_geometryOutputType == GEOMETRY_OUTPUT_TRIANGLES)
1368                 return GL_TRIANGLES;
1369         else if (m_geometryOutputType == GEOMETRY_OUTPUT_LINES)
1370                 return GL_LINES;
1371         else if (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS)
1372                 return GL_POINTS;
1373         else
1374         {
1375                 DE_ASSERT(false);
1376                 return -1;
1377         }
1378 }
1379
1380 const char* FeedbackPrimitiveTypeCase::getVertexSource (void) const
1381 {
1382         return s_positionVertexShader;
1383 }
1384
1385 const char* FeedbackPrimitiveTypeCase::getFragmentSource (void) const
1386 {
1387         return s_whiteOutputFragmentShader;
1388 }
1389
1390 std::string FeedbackPrimitiveTypeCase::getTessellationControlSource (void) const
1391 {
1392         std::ostringstream buf;
1393
1394         buf <<  "#version 310 es\n"
1395                         "#extension GL_EXT_tessellation_shader : require\n"
1396                         "layout(vertices = 9) out;\n"
1397                         "\n"
1398                         "uniform highp float u_innerTessellationLevel;\n"
1399                         "uniform highp float u_outerTessellationLevel;\n"
1400                         "\n"
1401                         "void main (void)\n"
1402                         "{\n"
1403                         "       if (gl_PatchVerticesIn != 4)\n"
1404                         "               return;\n"
1405                         "\n"
1406                         "       // Convert input 2x2 grid to 3x3 grid\n"
1407                         "       float xweight = float(gl_InvocationID % 3) / 2.0f;\n"
1408                         "       float yweight = float(gl_InvocationID / 3) / 2.0f;\n"
1409                         "\n"
1410                         "       vec4 y0 = mix(gl_in[0].gl_Position, gl_in[1].gl_Position, yweight);\n"
1411                         "       vec4 y1 = mix(gl_in[2].gl_Position, gl_in[3].gl_Position, yweight);\n"
1412                         "\n"
1413                         "       gl_out[gl_InvocationID].gl_Position = mix(y0, y1, xweight);\n"
1414                         "\n";
1415
1416         if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
1417                 buf <<  "       gl_TessLevelOuter[0] = 3.0;\n"
1418                                 "       gl_TessLevelOuter[1] = 3.0;\n"
1419                                 "       gl_TessLevelOuter[2] = 3.0;\n"
1420                                 "       gl_TessLevelInner[0] = 3.0;\n";
1421         else if (m_tessellationOutput == TESSELLATION_OUT_QUADS)
1422                 buf <<  "       gl_TessLevelOuter[0] = 3.0;\n"
1423                                 "       gl_TessLevelOuter[1] = 3.0;\n"
1424                                 "       gl_TessLevelOuter[2] = 3.0;\n"
1425                                 "       gl_TessLevelOuter[3] = 3.0;\n"
1426                                 "       gl_TessLevelInner[0] = 3.0;\n"
1427                                 "       gl_TessLevelInner[1] = 3.0;\n";
1428         else if (m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
1429                 buf <<  "       gl_TessLevelOuter[0] = 3.0;\n"
1430                                 "       gl_TessLevelOuter[1] = 3.0;\n";
1431         else
1432                 DE_ASSERT(false);
1433
1434         buf <<  "}\n";
1435
1436         return buf.str();
1437 }
1438
1439 std::string FeedbackPrimitiveTypeCase::getTessellationEvaluationSource (void) const
1440 {
1441         std::ostringstream buf;
1442
1443         buf <<  "#version 310 es\n"
1444                         "#extension GL_EXT_tessellation_shader : require\n"
1445                         "layout("
1446                                 << ((m_tessellationOutput == TESSELLATION_OUT_TRIANGLES) ? ("triangles") : (m_tessellationOutput == TESSELLATION_OUT_QUADS) ? ("quads") : ("isolines"))
1447                                 << ((m_tessellationPointMode) ? (", point_mode") : (""))
1448                                 << ") in;\n"
1449                         "\n"
1450                         "out highp vec4 v_tessellationCoords;\n"
1451                         "\n"
1452                         "void main (void)\n"
1453                         "{\n"
1454                         "       if (gl_PatchVerticesIn != 9)\n"
1455                         "               return;\n"
1456                         "\n"
1457                         "       vec4 patchCentroid = vec4(0.0);\n"
1458                         "       for (int ndx = 0; ndx < gl_PatchVerticesIn; ++ndx)\n"
1459                         "               patchCentroid += gl_in[ndx].gl_Position;\n"
1460                         "       patchCentroid /= patchCentroid.w;\n"
1461                         "\n";
1462
1463         if (m_tessellationOutput == TESSELLATION_OUT_TRIANGLES)
1464                 buf <<  "       // map barycentric coords to 2d coords\n"
1465                                 "       const vec3 tessDirX = vec3( 0.4,  0.4, 0.0);\n"
1466                                 "       const vec3 tessDirY = vec3( 0.0, -0.4, 0.0);\n"
1467                                 "       const vec3 tessDirZ = vec3(-0.4,  0.4, 0.0);\n"
1468                                 "       gl_Position = patchCentroid + vec4(gl_TessCoord.x * tessDirX + gl_TessCoord.y * tessDirY + gl_TessCoord.z * tessDirZ, 0.0);\n";
1469         else if (m_tessellationOutput == TESSELLATION_OUT_QUADS || m_tessellationOutput == TESSELLATION_OUT_ISOLINES)
1470                 buf <<  "       gl_Position = patchCentroid + vec4(gl_TessCoord.x * 0.8 - 0.4, gl_TessCoord.y * 0.8 - 0.4, 0.0, 0.0);\n";
1471         else
1472                 DE_ASSERT(false);
1473
1474         buf <<  "       v_tessellationCoords = vec4(gl_TessCoord, 0.0);\n"
1475                         "}\n";
1476
1477         return buf.str();
1478 }
1479
1480 std::string FeedbackPrimitiveTypeCase::getGeometrySource (void) const
1481 {
1482         const char* const       geometryInputPrimitive                  = (m_tessellationPointMode) ? ("points") : (m_tessellationOutput == TESSELLATION_OUT_ISOLINES) ? ("lines") : ("triangles");
1483         const char* const       geometryOutputPrimitive                 = (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS) ? ("points") : (m_geometryOutputType == GEOMETRY_OUTPUT_LINES) ? ("line_strip") : ("triangle_strip");
1484         const int                       numInputVertices                                = (m_tessellationPointMode) ? (1) : (m_tessellationOutput == TESSELLATION_OUT_ISOLINES) ? (2) : (3);
1485         const int                       numSingleVertexOutputVertices   = (m_geometryOutputType == GEOMETRY_OUTPUT_POINTS) ? (1) : (m_geometryOutputType == GEOMETRY_OUTPUT_LINES) ? (4) : (3);
1486         const int                       numEmitVertices                                 = numInputVertices * numSingleVertexOutputVertices;
1487         std::ostringstream      buf;
1488
1489         buf <<  "#version 310 es\n"
1490                         "#extension GL_EXT_geometry_shader : require\n"
1491                         "layout(" << geometryInputPrimitive << ") in;\n"
1492                         "layout(" << geometryOutputPrimitive << ", max_vertices=" << numEmitVertices <<") out;\n"
1493                         "\n"
1494                         "in highp vec4 v_tessellationCoords[];\n"
1495                         "out highp vec4 tf_someVertexPosition;\n"
1496                         "\n"
1497                         "void main (void)\n"
1498                         "{\n"
1499                         "       // Emit primitive\n"
1500                         "       for (int ndx = 0; ndx < gl_in.length(); ++ndx)\n"
1501                         "       {\n";
1502
1503         switch (m_geometryOutputType)
1504         {
1505                 case GEOMETRY_OUTPUT_POINTS:
1506                         buf <<  "               // Draw point on vertex\n"
1507                                         "               gl_Position = gl_in[ndx].gl_Position;\n"
1508                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1509                                         "               EmitVertex();\n";
1510                         break;
1511
1512                 case GEOMETRY_OUTPUT_LINES:
1513                         buf <<  "               // Draw cross on vertex\n"
1514                                         "               gl_Position = gl_in[ndx].gl_Position + vec4(-0.02, -0.02, 0.0, 0.0);\n"
1515                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1516                                         "               EmitVertex();\n"
1517                                         "               gl_Position = gl_in[ndx].gl_Position + vec4( 0.02,  0.02, 0.0, 0.0);\n"
1518                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1519                                         "               EmitVertex();\n"
1520                                         "               EndPrimitive();\n"
1521                                         "               gl_Position = gl_in[ndx].gl_Position + vec4( 0.02, -0.02, 0.0, 0.0);\n"
1522                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1523                                         "               EmitVertex();\n"
1524                                         "               gl_Position = gl_in[ndx].gl_Position + vec4(-0.02,  0.02, 0.0, 0.0);\n"
1525                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1526                                         "               EmitVertex();\n"
1527                                         "               EndPrimitive();\n";
1528                         break;
1529
1530                 case GEOMETRY_OUTPUT_TRIANGLES:
1531                         buf <<  "               // Draw triangle on vertex\n"
1532                                         "               gl_Position = gl_in[ndx].gl_Position + vec4(  0.00, -0.02, 0.0, 0.0);\n"
1533                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1534                                         "               EmitVertex();\n"
1535                                         "               gl_Position = gl_in[ndx].gl_Position + vec4(  0.02,  0.00, 0.0, 0.0);\n"
1536                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1537                                         "               EmitVertex();\n"
1538                                         "               gl_Position = gl_in[ndx].gl_Position + vec4( -0.02,  0.00, 0.0, 0.0);\n"
1539                                         "               tf_someVertexPosition = gl_in[gl_in.length() - 1].gl_Position;\n"
1540                                         "               EmitVertex();\n"
1541                                         "               EndPrimitive();\n";
1542                         break;
1543
1544                 default:
1545                         DE_ASSERT(false);
1546                         return "";
1547         }
1548
1549         buf <<  "       }\n"
1550                         "}\n";
1551
1552         return buf.str();
1553 }
1554
1555 const char* FeedbackPrimitiveTypeCase::getTessellationOutputDescription (TessellationOutputType tessellationOutput, TessellationPointMode pointMode)
1556 {
1557         switch (tessellationOutput)
1558         {
1559                 case TESSELLATION_OUT_TRIANGLES:        return (pointMode) ? ("points (triangles in point mode)") : ("triangles");
1560                 case TESSELLATION_OUT_QUADS:            return (pointMode) ? ("points (quads in point mode)")     : ("quads");
1561                 case TESSELLATION_OUT_ISOLINES:         return (pointMode) ? ("points (isolines in point mode)")  : ("isolines");
1562                 default:
1563                         DE_ASSERT(false);
1564                         return DE_NULL;
1565         }
1566 }
1567
1568 const char* FeedbackPrimitiveTypeCase::getGeometryInputDescription (TessellationOutputType tessellationOutput, TessellationPointMode pointMode)
1569 {
1570         switch (tessellationOutput)
1571         {
1572                 case TESSELLATION_OUT_TRIANGLES:        return (pointMode) ? ("points") : ("triangles");
1573                 case TESSELLATION_OUT_QUADS:            return (pointMode) ? ("points") : ("triangles");
1574                 case TESSELLATION_OUT_ISOLINES:         return (pointMode) ? ("points") : ("lines");
1575                 default:
1576                         DE_ASSERT(false);
1577                         return DE_NULL;
1578         }
1579 }
1580
1581 const char* FeedbackPrimitiveTypeCase::getGeometryOutputDescription (GeometryOutputType geometryOutput)
1582 {
1583         switch (geometryOutput)
1584         {
1585                 case GEOMETRY_OUTPUT_POINTS:            return "points";
1586                 case GEOMETRY_OUTPUT_LINES:                     return "lines";
1587                 case GEOMETRY_OUTPUT_TRIANGLES:         return "triangles";
1588                 default:
1589                         DE_ASSERT(false);
1590                         return DE_NULL;
1591         }
1592 }
1593
1594 class PointSizeCase : public TestCase
1595 {
1596 public:
1597         enum Flags
1598         {
1599                 FLAG_VERTEX_SET                                         = 0x01,         // !< set gl_PointSize in vertex shader
1600                 FLAG_TESSELLATION_CONTROL_SET           = 0x02,         // !< set gl_PointSize in tessellation evaluation shader
1601                 FLAG_TESSELLATION_EVALUATION_SET        = 0x04,         // !< set gl_PointSize in tessellation control shader
1602                 FLAG_TESSELLATION_ADD                           = 0x08,         // !< read and add to gl_PointSize in tessellation shader pair
1603                 FLAG_TESSELLATION_DONT_SET                      = 0x10,         // !< don't set gl_PointSize in tessellation shader
1604                 FLAG_GEOMETRY_SET                                       = 0x20,         // !< set gl_PointSize in geometry shader
1605                 FLAG_GEOMETRY_ADD                                       = 0x40,         // !< read and add to gl_PointSize in geometry shader
1606                 FLAG_GEOMETRY_DONT_SET                          = 0x80,         // !< don't set gl_PointSize in geometry shader
1607         };
1608
1609                                                 PointSizeCase                                   (Context& context, const char* name, const char* description, int flags);
1610                                                 ~PointSizeCase                                  (void);
1611
1612         static std::string      genTestCaseName                                 (int flags);
1613         static std::string      genTestCaseDescription                  (int flags);
1614
1615 private:
1616         void                            init                                                    (void);
1617         void                            deinit                                                  (void);
1618         IterateResult           iterate                                                 (void);
1619
1620         void                            checkExtensions                                 (void) const;
1621         void                            checkPointSizeRequirements              (void) const;
1622
1623         void                            renderTo                                                (tcu::Surface& dst);
1624         bool                            verifyImage                                             (const tcu::Surface& src);
1625         int                                     getExpectedPointSize                    (void) const;
1626
1627         std::string                     genVertexSource                                 (void) const;
1628         const char*                     genFragmentSource                               (void) const;
1629         std::string                     genTessellationControlSource    (void) const;
1630         std::string                     genTessellationEvaluationSource (void) const;
1631         std::string                     genGeometrySource                               (void) const;
1632
1633         enum
1634         {
1635                 RENDER_SIZE = 32,
1636         };
1637
1638         const int                       m_flags;
1639         glu::ShaderProgram*     m_program;
1640 };
1641
1642 PointSizeCase::PointSizeCase (Context& context, const char* name, const char* description, int flags)
1643         : TestCase      (context, name, description)
1644         , m_flags       (flags)
1645         , m_program     (DE_NULL)
1646 {
1647 }
1648
1649 PointSizeCase::~PointSizeCase (void)
1650 {
1651         deinit();
1652 }
1653
1654 std::string PointSizeCase::genTestCaseName (int flags)
1655 {
1656         std::ostringstream buf;
1657
1658         // join per-bit descriptions into a single string with '_' separator
1659         if (flags & FLAG_VERTEX_SET)                                    buf                                                                                                                                             << "vertex_set";
1660         if (flags & FLAG_TESSELLATION_CONTROL_SET)              buf << ((flags & (FLAG_TESSELLATION_CONTROL_SET-1))             ? ("_") : ("")) << "control_set";
1661         if (flags & FLAG_TESSELLATION_EVALUATION_SET)   buf << ((flags & (FLAG_TESSELLATION_EVALUATION_SET-1))  ? ("_") : ("")) << "evaluation_set";
1662         if (flags & FLAG_TESSELLATION_ADD)                              buf << ((flags & (FLAG_TESSELLATION_ADD-1))                             ? ("_") : ("")) << "control_pass_eval_add";
1663         if (flags & FLAG_TESSELLATION_DONT_SET)                 buf << ((flags & (FLAG_TESSELLATION_DONT_SET-1))                ? ("_") : ("")) << "eval_default";
1664         if (flags & FLAG_GEOMETRY_SET)                                  buf << ((flags & (FLAG_GEOMETRY_SET-1))                                 ? ("_") : ("")) << "geometry_set";
1665         if (flags & FLAG_GEOMETRY_ADD)                                  buf << ((flags & (FLAG_GEOMETRY_ADD-1))                                 ? ("_") : ("")) << "geometry_add";
1666         if (flags & FLAG_GEOMETRY_DONT_SET)                             buf << ((flags & (FLAG_GEOMETRY_DONT_SET-1))                    ? ("_") : ("")) << "geometry_default";
1667
1668         return buf.str();
1669 }
1670
1671 std::string PointSizeCase::genTestCaseDescription (int flags)
1672 {
1673         std::ostringstream buf;
1674
1675         // join per-bit descriptions into a single string with ", " separator
1676         if (flags & FLAG_VERTEX_SET)                                    buf                                                                                                                                                     << "set point size in vertex shader";
1677         if (flags & FLAG_TESSELLATION_CONTROL_SET)              buf << ((flags & (FLAG_TESSELLATION_CONTROL_SET-1))             ? (", ") : (""))        << "set point size in tessellation control shader";
1678         if (flags & FLAG_TESSELLATION_EVALUATION_SET)   buf << ((flags & (FLAG_TESSELLATION_EVALUATION_SET-1))  ? (", ") : (""))        << "set point size in tessellation evaluation shader";
1679         if (flags & FLAG_TESSELLATION_ADD)                              buf << ((flags & (FLAG_TESSELLATION_ADD-1))                             ? (", ") : (""))        << "add to point size in tessellation shader";
1680         if (flags & FLAG_TESSELLATION_DONT_SET)                 buf << ((flags & (FLAG_TESSELLATION_DONT_SET-1))                ? (", ") : (""))        << "don't set point size in tessellation evaluation shader";
1681         if (flags & FLAG_GEOMETRY_SET)                                  buf << ((flags & (FLAG_GEOMETRY_SET-1))                                 ? (", ") : (""))        << "set point size in geometry shader";
1682         if (flags & FLAG_GEOMETRY_ADD)                                  buf << ((flags & (FLAG_GEOMETRY_ADD-1))                                 ? (", ") : (""))        << "add to point size in geometry shader";
1683         if (flags & FLAG_GEOMETRY_DONT_SET)                             buf << ((flags & (FLAG_GEOMETRY_DONT_SET-1))                    ? (", ") : (""))        << "don't set point size in geometry shader";
1684
1685         return buf.str();
1686 }
1687
1688 void PointSizeCase::init (void)
1689 {
1690         checkExtensions();
1691         checkPointSizeRequirements();
1692
1693         // log
1694
1695         if (m_flags & FLAG_VERTEX_SET)
1696                 m_testCtx.getLog() << tcu::TestLog::Message << "Setting point size in vertex shader to 2.0." << tcu::TestLog::EndMessage;
1697         if (m_flags & FLAG_TESSELLATION_CONTROL_SET)
1698                 m_testCtx.getLog() << tcu::TestLog::Message << "Setting point size in tessellation control shader to 4.0. (And ignoring it in evaluation)." << tcu::TestLog::EndMessage;
1699         if (m_flags & FLAG_TESSELLATION_EVALUATION_SET)
1700                 m_testCtx.getLog() << tcu::TestLog::Message << "Setting point size in tessellation evaluation shader to 4.0." << tcu::TestLog::EndMessage;
1701         if (m_flags & FLAG_TESSELLATION_ADD)
1702                 m_testCtx.getLog() << tcu::TestLog::Message << "Reading point size in tessellation control shader and adding 2.0 to it in evaluation." << tcu::TestLog::EndMessage;
1703         if (m_flags & FLAG_TESSELLATION_DONT_SET)
1704                 m_testCtx.getLog() << tcu::TestLog::Message << "Not setting point size in tessellation evaluation shader (resulting in the default point size)." << tcu::TestLog::EndMessage;
1705         if (m_flags & FLAG_GEOMETRY_SET)
1706                 m_testCtx.getLog() << tcu::TestLog::Message << "Setting point size in geometry shader to 6.0." << tcu::TestLog::EndMessage;
1707         if (m_flags & FLAG_GEOMETRY_ADD)
1708                 m_testCtx.getLog() << tcu::TestLog::Message << "Reading point size in geometry shader and adding 2.0." << tcu::TestLog::EndMessage;
1709         if (m_flags & FLAG_GEOMETRY_DONT_SET)
1710                 m_testCtx.getLog() << tcu::TestLog::Message << "Not setting point size in geometry shader (resulting in the default point size)." << tcu::TestLog::EndMessage;
1711
1712         // program
1713
1714         {
1715                 glu::ProgramSources sources;
1716                 sources << glu::VertexSource(genVertexSource())
1717                                 << glu::FragmentSource(genFragmentSource());
1718
1719                 if (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET | FLAG_TESSELLATION_ADD | FLAG_TESSELLATION_DONT_SET))
1720                         sources << glu::TessellationControlSource(genTessellationControlSource())
1721                                         << glu::TessellationEvaluationSource(genTessellationEvaluationSource());
1722
1723                 if (m_flags & (FLAG_GEOMETRY_SET | FLAG_GEOMETRY_ADD | FLAG_GEOMETRY_DONT_SET))
1724                         sources << glu::GeometrySource(genGeometrySource());
1725
1726                 m_program = new glu::ShaderProgram(m_context.getRenderContext(), sources);
1727
1728                 m_testCtx.getLog() << *m_program;
1729                 if (!m_program->isOk())
1730                         throw tcu::TestError("failed to build program");
1731         }
1732 }
1733
1734 void PointSizeCase::deinit (void)
1735 {
1736         delete m_program;
1737         m_program = DE_NULL;
1738 }
1739
1740 PointSizeCase::IterateResult PointSizeCase::iterate (void)
1741 {
1742         tcu::Surface resultImage(RENDER_SIZE, RENDER_SIZE);
1743
1744         renderTo(resultImage);
1745
1746         if (verifyImage(resultImage))
1747                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
1748         else
1749                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
1750
1751         return STOP;
1752 }
1753
1754 void PointSizeCase::checkExtensions (void) const
1755 {
1756         std::vector<std::string>        requiredExtensions;
1757         bool                                            allOk                           = true;
1758
1759         if (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET | FLAG_TESSELLATION_ADD | FLAG_TESSELLATION_DONT_SET))
1760                 requiredExtensions.push_back("GL_EXT_tessellation_shader");
1761
1762         if (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET | FLAG_TESSELLATION_ADD))
1763                 requiredExtensions.push_back("GL_EXT_tessellation_point_size");
1764
1765         if (m_flags & (m_flags & (FLAG_GEOMETRY_SET | FLAG_GEOMETRY_ADD | FLAG_GEOMETRY_DONT_SET)))
1766                 requiredExtensions.push_back("GL_EXT_geometry_shader");
1767
1768         if (m_flags & (m_flags & (FLAG_GEOMETRY_SET | FLAG_GEOMETRY_ADD)))
1769                 requiredExtensions.push_back("GL_EXT_geometry_point_size");
1770
1771         for (int ndx = 0; ndx < (int)requiredExtensions.size(); ++ndx)
1772                 if (!m_context.getContextInfo().isExtensionSupported(requiredExtensions[ndx].c_str()))
1773                         allOk = false;
1774
1775         if (!allOk)
1776         {
1777                 std::ostringstream extensionList;
1778
1779                 for (int ndx = 0; ndx < (int)requiredExtensions.size(); ++ndx)
1780                 {
1781                         if (ndx != 0)
1782                                 extensionList << ", ";
1783                         extensionList << requiredExtensions[ndx];
1784                 }
1785
1786                 throw tcu::NotSupportedError("Test requires {" + extensionList.str() + "} extension(s)");
1787         }
1788 }
1789
1790 void PointSizeCase::checkPointSizeRequirements (void) const
1791 {
1792         const glw::Functions&   gl                                      = m_context.getRenderContext().getFunctions();
1793         float                                   aliasedSizeRange[2]     = { 0.0f, 0.0f };
1794         const int                               requiredSize            = getExpectedPointSize();
1795
1796         gl.getFloatv(GL_ALIASED_POINT_SIZE_RANGE, aliasedSizeRange);
1797
1798         if (float(requiredSize) > aliasedSizeRange[1])
1799                 throw tcu::NotSupportedError("Test requires point size " + de::toString(requiredSize));
1800 }
1801
1802 void PointSizeCase::renderTo (tcu::Surface& dst)
1803 {
1804         const glw::Functions&   gl                                      = m_context.getRenderContext().getFunctions();
1805         const bool                              tessellationActive      = (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_EVALUATION_SET | FLAG_TESSELLATION_ADD | FLAG_TESSELLATION_DONT_SET)) != 0;
1806         const int                               positionLocation        = gl.getAttribLocation(m_program->getProgram(), "a_position");
1807         const glu::VertexArray  vao                                     (m_context.getRenderContext());
1808
1809         m_testCtx.getLog() << tcu::TestLog::Message << "Rendering single point." << tcu::TestLog::EndMessage;
1810
1811         if (positionLocation == -1)
1812                 throw tcu::TestError("Attribute a_position location was -1");
1813
1814         gl.viewport(0, 0, RENDER_SIZE, RENDER_SIZE);
1815         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
1816         gl.clear(GL_COLOR_BUFFER_BIT);
1817         GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
1818
1819         gl.bindVertexArray(*vao);
1820         GLU_EXPECT_NO_ERROR(gl.getError(), "bind vao");
1821
1822         gl.useProgram(m_program->getProgram());
1823         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
1824
1825         gl.vertexAttrib4f(positionLocation, 0.0f, 0.0f, 0.0f, 1.0f);
1826
1827         if (tessellationActive)
1828         {
1829                 gl.patchParameteri(GL_PATCH_VERTICES, 1);
1830                 GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
1831
1832                 gl.drawArrays(GL_PATCHES, 0, 1);
1833                 GLU_EXPECT_NO_ERROR(gl.getError(), "draw patches");
1834         }
1835         else
1836         {
1837                 gl.drawArrays(GL_POINTS, 0, 1);
1838                 GLU_EXPECT_NO_ERROR(gl.getError(), "draw points");
1839         }
1840
1841         glu::readPixels(m_context.getRenderContext(), 0, 0, dst.getAccess());
1842 }
1843
1844 bool PointSizeCase::verifyImage (const tcu::Surface& src)
1845 {
1846         const bool MSAATarget   = (m_context.getRenderTarget().getNumSamples() > 1);
1847         const int expectedSize  = getExpectedPointSize();
1848
1849         m_testCtx.getLog() << tcu::TestLog::Message << "Verifying rendered point size. Expecting " << expectedSize << " pixels." << tcu::TestLog::EndMessage;
1850         m_testCtx.getLog() << tcu::TestLog::Image("RenderImage", "Rendered image", src.getAccess());
1851
1852         {
1853                 bool            resultAreaFound = false;
1854                 tcu::IVec4      resultArea;
1855
1856                 // Find rasterization output area
1857
1858                 for (int y = 0; y < src.getHeight(); ++y)
1859                 for (int x = 0; x < src.getWidth();  ++x)
1860                 {
1861                         if (!isBlack(src.getPixel(x, y)))
1862                         {
1863                                 if (!resultAreaFound)
1864                                 {
1865                                         // first fragment
1866                                         resultArea = tcu::IVec4(x, y, x + 1, y + 1);
1867                                         resultAreaFound = true;
1868                                 }
1869                                 else
1870                                 {
1871                                         // union area
1872                                         resultArea.x() = de::min(resultArea.x(), x);
1873                                         resultArea.y() = de::min(resultArea.y(), y);
1874                                         resultArea.z() = de::max(resultArea.z(), x+1);
1875                                         resultArea.w() = de::max(resultArea.w(), y+1);
1876                                 }
1877                         }
1878                 }
1879
1880                 if (!resultAreaFound)
1881                 {
1882                         m_testCtx.getLog() << tcu::TestLog::Message << "Verification failed, could not find any point fragments." << tcu::TestLog::EndMessage;
1883                         return false;
1884                 }
1885
1886                 // verify area size
1887                 if (MSAATarget)
1888                 {
1889                         const tcu::IVec2 pointSize = resultArea.swizzle(2,3) - resultArea.swizzle(0, 1);
1890
1891                         // MSAA: edges may be a little fuzzy
1892                         if (de::abs(pointSize.x() - pointSize.y()) > 1)
1893                         {
1894                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Rasterized point is not a square. Detected point size was " << pointSize << tcu::TestLog::EndMessage;
1895                                 return false;
1896                         }
1897
1898                         // MSAA may produce larger areas, allow one pixel larger
1899                         if (expectedSize != de::max(pointSize.x(), pointSize.y()) && (expectedSize+1) != de::max(pointSize.x(), pointSize.y()))
1900                         {
1901                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Point size invalid, expected " << expectedSize << ", got " << de::max(pointSize.x(), pointSize.y()) << tcu::TestLog::EndMessage;
1902                                 return false;
1903                         }
1904                 }
1905                 else
1906                 {
1907                         const tcu::IVec2 pointSize = resultArea.swizzle(2,3) - resultArea.swizzle(0, 1);
1908
1909                         if (pointSize.x() != pointSize.y())
1910                         {
1911                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Rasterized point is not a square. Point size was " << pointSize << tcu::TestLog::EndMessage;
1912                                 return false;
1913                         }
1914
1915                         if (pointSize.x() != expectedSize)
1916                         {
1917                                 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR! Point size invalid, expected " << expectedSize << ", got " << pointSize.x() << tcu::TestLog::EndMessage;
1918                                 return false;
1919                         }
1920                 }
1921         }
1922
1923         return true;
1924 }
1925
1926 int PointSizeCase::getExpectedPointSize (void) const
1927 {
1928         int addition = 0;
1929
1930         // geometry
1931         if (m_flags & FLAG_GEOMETRY_DONT_SET)
1932                 return 1;
1933         else if (m_flags & FLAG_GEOMETRY_SET)
1934                 return 6;
1935         else if (m_flags & FLAG_GEOMETRY_ADD)
1936                 addition += 2;
1937
1938         // tessellation
1939         if (m_flags & FLAG_TESSELLATION_EVALUATION_SET)
1940                 return 4 + addition;
1941         else if (m_flags & FLAG_TESSELLATION_ADD)
1942                 addition += 2;
1943         else if (m_flags & (FLAG_TESSELLATION_CONTROL_SET | FLAG_TESSELLATION_DONT_SET))
1944         {
1945                 DE_ASSERT((m_flags & FLAG_GEOMETRY_ADD) == 0); // reading pointSize undefined
1946                 return 1;
1947         }
1948
1949         // vertex
1950         if (m_flags & FLAG_VERTEX_SET)
1951                 return 2 + addition;
1952
1953         // undefined
1954         DE_ASSERT(false);
1955         return -1;
1956 }
1957
1958 std::string PointSizeCase::genVertexSource (void) const
1959 {
1960         std::ostringstream buf;
1961
1962         buf     << "#version 310 es\n"
1963                 << "in highp vec4 a_position;\n"
1964                 << "void main ()\n"
1965                 << "{\n"
1966                 << "    gl_Position = a_position;\n";
1967
1968         if (m_flags & FLAG_VERTEX_SET)
1969                 buf << "        gl_PointSize = 2.0;\n";
1970
1971         buf     << "}\n";
1972
1973         return buf.str();
1974 }
1975
1976 const char* PointSizeCase::genFragmentSource (void) const
1977 {
1978         return s_whiteOutputFragmentShader;
1979 }
1980
1981 std::string PointSizeCase::genTessellationControlSource (void) const
1982 {
1983         std::ostringstream buf;
1984
1985         buf     << "#version 310 es\n"
1986                 << "#extension GL_EXT_tessellation_shader : require\n"
1987                 << ((m_flags & FLAG_TESSELLATION_DONT_SET) ? ("") : ("#extension GL_EXT_tessellation_point_size : require\n"))
1988                 << "layout(vertices = 1) out;\n"
1989                 << "void main ()\n"
1990                 << "{\n"
1991                 << "    gl_TessLevelOuter[0] = 3.0;\n"
1992                 << "    gl_TessLevelOuter[1] = 3.0;\n"
1993                 << "    gl_TessLevelOuter[2] = 3.0;\n"
1994                 << "    gl_TessLevelInner[0] = 3.0;\n"
1995                 << "    gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n";
1996
1997         if (m_flags & FLAG_TESSELLATION_ADD)
1998                 buf << "        // pass as is to eval\n"
1999                         << "    gl_out[gl_InvocationID].gl_PointSize = gl_in[gl_InvocationID].gl_PointSize;\n";
2000         else if (m_flags & FLAG_TESSELLATION_CONTROL_SET)
2001                 buf << "        // thrown away\n"
2002                         << "    gl_out[gl_InvocationID].gl_PointSize = 4.0;\n";
2003
2004         buf     << "}\n";
2005
2006         return buf.str();
2007 }
2008
2009 std::string PointSizeCase::genTessellationEvaluationSource (void) const
2010 {
2011         std::ostringstream buf;
2012
2013         buf     << "#version 310 es\n"
2014                 << "#extension GL_EXT_tessellation_shader : require\n"
2015                 << ((m_flags & FLAG_TESSELLATION_DONT_SET) ? ("") : ("#extension GL_EXT_tessellation_point_size : require\n"))
2016                 << "layout(triangles, point_mode) in;\n"
2017                 << "void main ()\n"
2018                 << "{\n"
2019                 << "    // hide all but one vertex\n"
2020                 << "    if (gl_TessCoord.x < 0.99)\n"
2021                 << "            gl_Position = vec4(-2.0, 0.0, 0.0, 1.0);\n"
2022                 << "    else\n"
2023                 << "            gl_Position = gl_in[0].gl_Position;\n";
2024
2025         if (m_flags & FLAG_TESSELLATION_ADD)
2026                 buf << "\n"
2027                         << "    // add to point size\n"
2028                         << "    gl_PointSize = gl_in[0].gl_PointSize + 2.0;\n";
2029         else if (m_flags & FLAG_TESSELLATION_EVALUATION_SET)
2030                 buf << "\n"
2031                         << "    // set point size\n"
2032                         << "    gl_PointSize = 4.0;\n";
2033
2034         buf     << "}\n";
2035
2036         return buf.str();
2037 }
2038
2039 std::string PointSizeCase::genGeometrySource (void) const
2040 {
2041         std::ostringstream buf;
2042
2043         buf     << "#version 310 es\n"
2044                 << "#extension GL_EXT_geometry_shader : require\n"
2045                 << ((m_flags & FLAG_GEOMETRY_DONT_SET) ? ("") : ("#extension GL_EXT_geometry_point_size : require\n"))
2046                 << "layout (points) in;\n"
2047                 << "layout (points, max_vertices=1) out;\n"
2048                 << "\n"
2049                 << "void main ()\n"
2050                 << "{\n";
2051
2052         if (m_flags & FLAG_GEOMETRY_SET)
2053                 buf     << "    gl_Position = gl_in[0].gl_Position;\n"
2054                         << "    gl_PointSize = 6.0;\n";
2055         else if (m_flags & FLAG_GEOMETRY_ADD)
2056                 buf     << "    gl_Position = gl_in[0].gl_Position;\n"
2057                         << "    gl_PointSize = gl_in[0].gl_PointSize + 2.0;\n";
2058         else if (m_flags & FLAG_GEOMETRY_DONT_SET)
2059                 buf     << "    gl_Position = gl_in[0].gl_Position;\n";
2060
2061         buf     << "    EmitVertex();\n"
2062                 << "}\n";
2063
2064         return buf.str();
2065 }
2066
2067 class AllowedRenderFailureException : public std::runtime_error
2068 {
2069 public:
2070         AllowedRenderFailureException (const char* message) : std::runtime_error(message) { }
2071 };
2072
2073 class GridRenderCase : public TestCase
2074 {
2075 public:
2076         enum Flags
2077         {
2078                 FLAG_TESSELLATION_MAX_SPEC                                              = 0x0001,
2079                 FLAG_TESSELLATION_MAX_IMPLEMENTATION                    = 0x0002,
2080                 FLAG_GEOMETRY_MAX_SPEC                                                  = 0x0004,
2081                 FLAG_GEOMETRY_MAX_IMPLEMENTATION                                = 0x0008,
2082                 FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC                              = 0x0010,
2083                 FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION    = 0x0020,
2084
2085                 FLAG_GEOMETRY_SCATTER_INSTANCES                                 = 0x0040,
2086                 FLAG_GEOMETRY_SCATTER_PRIMITIVES                                = 0x0080,
2087                 FLAG_GEOMETRY_SEPARATE_PRIMITIVES                               = 0x0100, //!< if set, geometry shader outputs separate grid cells and not continuous slices
2088                 FLAG_GEOMETRY_SCATTER_LAYERS                                    = 0x0200,
2089
2090                 FLAG_ALLOW_OUT_OF_MEMORY                                                = 0x0400, //!< allow draw command to set GL_OUT_OF_MEMORY
2091         };
2092
2093                                                 GridRenderCase                                  (Context& context, const char* name, const char* description, int flags);
2094                                                 ~GridRenderCase                                 (void);
2095
2096 private:
2097         void                            init                                                    (void);
2098         void                            deinit                                                  (void);
2099         IterateResult           iterate                                                 (void);
2100
2101         void                            renderTo                                                (std::vector<tcu::Surface>& dst);
2102         bool                            verifyResultLayer                               (int layerNdx, const tcu::Surface& dst);
2103
2104         const char*                     getVertexSource                                 (void);
2105         const char*                     getFragmentSource                               (void);
2106         std::string                     getTessellationControlSource    (int tessLevel);
2107         std::string                     getTessellationEvaluationSource (int tessLevel);
2108         std::string                     getGeometryShaderSource                 (int numPrimitives, int numInstances, int tessLevel);
2109
2110         enum
2111         {
2112                 RENDER_SIZE = 256
2113         };
2114
2115         const int                       m_flags;
2116
2117         glu::ShaderProgram*     m_program;
2118         deUint32                        m_texture;
2119         int                                     m_numLayers;
2120 };
2121
2122 GridRenderCase::GridRenderCase (Context& context, const char* name, const char* description, int flags)
2123         : TestCase              (context, name, description)
2124         , m_flags               (flags)
2125         , m_program             (DE_NULL)
2126         , m_texture             (0)
2127         , m_numLayers   (1)
2128 {
2129         DE_ASSERT(((m_flags & FLAG_TESSELLATION_MAX_SPEC) == 0)                 || ((m_flags & FLAG_TESSELLATION_MAX_IMPLEMENTATION) == 0));
2130         DE_ASSERT(((m_flags & FLAG_GEOMETRY_MAX_SPEC) == 0)                             || ((m_flags & FLAG_GEOMETRY_MAX_IMPLEMENTATION) == 0));
2131         DE_ASSERT(((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC) == 0) || ((m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION) == 0));
2132         DE_ASSERT(((m_flags & (FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS)) != 0) == ((m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0));
2133 }
2134
2135 GridRenderCase::~GridRenderCase (void)
2136 {
2137         deinit();
2138 }
2139
2140 void GridRenderCase::init (void)
2141 {
2142         const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2143
2144         // Requirements
2145
2146         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
2147                 !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
2148                 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
2149
2150         if ((m_flags & FLAG_GEOMETRY_SCATTER_LAYERS) == 0)
2151         {
2152                 if (m_context.getRenderTarget().getWidth() < RENDER_SIZE ||
2153                         m_context.getRenderTarget().getHeight() < RENDER_SIZE)
2154                         throw tcu::NotSupportedError("Test requires " + de::toString<int>(RENDER_SIZE) + "x" + de::toString<int>(RENDER_SIZE) + " or larger render target.");
2155         }
2156
2157         // Log
2158
2159         m_testCtx.getLog()
2160                 << tcu::TestLog::Message
2161                 << "Testing tessellation and geometry shaders that output a large number of primitives.\n"
2162                 << getDescription()
2163                 << tcu::TestLog::EndMessage;
2164
2165         // Render target
2166         if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
2167         {
2168                 // set limits
2169                 m_numLayers = 8;
2170
2171                 m_testCtx.getLog() << tcu::TestLog::Message << "Rendering to 2d texture array, numLayers = " << m_numLayers << tcu::TestLog::EndMessage;
2172
2173                 gl.genTextures(1, &m_texture);
2174                 gl.bindTexture(GL_TEXTURE_2D_ARRAY, m_texture);
2175                 gl.texStorage3D(GL_TEXTURE_2D_ARRAY, 1, GL_RGBA8, RENDER_SIZE, RENDER_SIZE, m_numLayers);
2176
2177                 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
2178                 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
2179                 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
2180                 gl.texParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
2181
2182                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen texture");
2183         }
2184
2185         // Gen program
2186         {
2187                 glu::ProgramSources     sources;
2188                 int                                     tessGenLevel = -1;
2189
2190                 sources << glu::VertexSource(getVertexSource())
2191                                 << glu::FragmentSource(getFragmentSource());
2192
2193                 // Tessellation limits
2194                 {
2195                         if (m_flags & FLAG_TESSELLATION_MAX_IMPLEMENTATION)
2196                         {
2197                                 gl.getIntegerv(GL_MAX_TESS_GEN_LEVEL, &tessGenLevel);
2198                                 GLU_EXPECT_NO_ERROR(gl.getError(), "query tessellation limits");
2199                         }
2200                         else if (m_flags & FLAG_TESSELLATION_MAX_SPEC)
2201                         {
2202                                 tessGenLevel = 64;
2203                         }
2204                         else
2205                         {
2206                                 tessGenLevel = 5;
2207                         }
2208
2209                         m_testCtx.getLog()
2210                                         << tcu::TestLog::Message
2211                                         << "Tessellation level: " << tessGenLevel << ", mode = quad.\n"
2212                                         << "\tEach input patch produces " << (tessGenLevel*tessGenLevel) << " (" << (tessGenLevel*tessGenLevel*2) << " triangles)\n"
2213                                         << tcu::TestLog::EndMessage;
2214
2215                         sources << glu::TessellationControlSource(getTessellationControlSource(tessGenLevel))
2216                                         << glu::TessellationEvaluationSource(getTessellationEvaluationSource(tessGenLevel));
2217                 }
2218
2219                 // Geometry limits
2220                 {
2221                         int             geometryOutputComponents                = -1;
2222                         int             geometryOutputVertices                  = -1;
2223                         int             geometryTotalOutputComponents   = -1;
2224                         int             geometryShaderInvocations               = -1;
2225                         bool    logGeometryLimits                               = false;
2226                         bool    logInvocationLimits                             = false;
2227
2228                         if (m_flags & FLAG_GEOMETRY_MAX_IMPLEMENTATION)
2229                         {
2230                                 m_testCtx.getLog() << tcu::TestLog::Message << "Using implementation maximum geometry shader output limits." << tcu::TestLog::EndMessage;
2231
2232                                 gl.getIntegerv(GL_MAX_GEOMETRY_OUTPUT_COMPONENTS, &geometryOutputComponents);
2233                                 gl.getIntegerv(GL_MAX_GEOMETRY_OUTPUT_VERTICES, &geometryOutputVertices);
2234                                 gl.getIntegerv(GL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS, &geometryTotalOutputComponents);
2235                                 GLU_EXPECT_NO_ERROR(gl.getError(), "query geometry limits");
2236
2237                                 logGeometryLimits = true;
2238                         }
2239                         else if (m_flags & FLAG_GEOMETRY_MAX_SPEC)
2240                         {
2241                                 m_testCtx.getLog() << tcu::TestLog::Message << "Using geometry shader extension minimum maximum output limits." << tcu::TestLog::EndMessage;
2242
2243                                 geometryOutputComponents = 128;
2244                                 geometryOutputVertices = 256;
2245                                 geometryTotalOutputComponents = 1024;
2246                                 logGeometryLimits = true;
2247                         }
2248                         else
2249                         {
2250                                 geometryOutputComponents = 128;
2251                                 geometryOutputVertices = 16;
2252                                 geometryTotalOutputComponents = 1024;
2253                         }
2254
2255                         if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION)
2256                         {
2257                                 gl.getIntegerv(GL_MAX_GEOMETRY_SHADER_INVOCATIONS, &geometryShaderInvocations);
2258                                 GLU_EXPECT_NO_ERROR(gl.getError(), "query geometry invocation limits");
2259
2260                                 logInvocationLimits = true;
2261                         }
2262                         else if (m_flags & FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC)
2263                         {
2264                                 geometryShaderInvocations = 32;
2265                                 logInvocationLimits = true;
2266                         }
2267                         else
2268                         {
2269                                 geometryShaderInvocations = 4;
2270                         }
2271
2272                         if (logGeometryLimits || logInvocationLimits)
2273                         {
2274                                 tcu::MessageBuilder msg(&m_testCtx.getLog());
2275
2276                                 msg << "Geometry shader, targeting following limits:\n";
2277
2278                                 if (logGeometryLimits)
2279                                         msg     << "\tGL_MAX_GEOMETRY_OUTPUT_COMPONENTS = " << geometryOutputComponents << "\n"
2280                                                 << "\tGL_MAX_GEOMETRY_OUTPUT_VERTICES = " << geometryOutputVertices << "\n"
2281                                                 << "\tGL_MAX_GEOMETRY_TOTAL_OUTPUT_COMPONENTS = " << geometryTotalOutputComponents << "\n";
2282
2283                                 if (logInvocationLimits)
2284                                         msg << "\tGL_MAX_GEOMETRY_SHADER_INVOCATIONS = " << geometryShaderInvocations;
2285
2286                                 msg << tcu::TestLog::EndMessage;
2287                         }
2288
2289                         {
2290                                 const bool      separatePrimitives                      = (m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) != 0;
2291                                 const int       numComponentsPerVertex          = 8; // vec4 pos, vec4 color
2292                                 int                     numVerticesPerInvocation;
2293                                 int                     numPrimitivesPerInvocation;
2294                                 int                     geometryVerticesPerPrimitive;
2295                                 int                     geometryPrimitivesOutPerPrimitive;
2296
2297                                 if (separatePrimitives)
2298                                 {
2299                                         const int       numComponentLimit       = geometryTotalOutputComponents / (4 * numComponentsPerVertex);
2300                                         const int       numOutputLimit          = geometryOutputVertices / 4;
2301
2302                                         numPrimitivesPerInvocation              = de::min(numComponentLimit, numOutputLimit);
2303                                         numVerticesPerInvocation                = numPrimitivesPerInvocation * 4;
2304                                 }
2305                                 else
2306                                 {
2307                                         // If FLAG_GEOMETRY_SEPARATE_PRIMITIVES is not set, geometry shader fills a rectangle area in slices.
2308                                         // Each slice is a triangle strip and is generated by a single shader invocation.
2309                                         // One slice with 4 segment ends (nodes) and 3 segments:
2310                                         //    .__.__.__.
2311                                         //    |\ |\ |\ |
2312                                         //    |_\|_\|_\|
2313
2314                                         const int       numSliceNodesComponentLimit     = geometryTotalOutputComponents / (2 * numComponentsPerVertex);                 // each node 2 vertices
2315                                         const int       numSliceNodesOutputLimit        = geometryOutputVertices / 2;                                                                                   // each node 2 vertices
2316                                         const int       numSliceNodes                           = de::min(numSliceNodesComponentLimit, numSliceNodesOutputLimit);
2317
2318                                         numVerticesPerInvocation                                = numSliceNodes * 2;
2319                                         numPrimitivesPerInvocation                              = (numSliceNodes - 1) * 2;
2320                                 }
2321
2322                                 geometryVerticesPerPrimitive = numVerticesPerInvocation * geometryShaderInvocations;
2323                                 geometryPrimitivesOutPerPrimitive = numPrimitivesPerInvocation * geometryShaderInvocations;
2324
2325                                 m_testCtx.getLog()
2326                                         << tcu::TestLog::Message
2327                                         << "Geometry shader:\n"
2328                                         << "\tTotal output vertex count per invocation: " << (numVerticesPerInvocation) << "\n"
2329                                         << "\tTotal output primitive count per invocation: " << (numPrimitivesPerInvocation) << "\n"
2330                                         << "\tNumber of invocations per primitive: " << geometryShaderInvocations << "\n"
2331                                         << "\tTotal output vertex count per input primitive: " << (geometryVerticesPerPrimitive) << "\n"
2332                                         << "\tTotal output primitive count per input primitive: " << (geometryPrimitivesOutPerPrimitive) << "\n"
2333                                         << tcu::TestLog::EndMessage;
2334
2335                                 sources << glu::GeometrySource(getGeometryShaderSource(numPrimitivesPerInvocation, geometryShaderInvocations, tessGenLevel));
2336
2337                                 m_testCtx.getLog()
2338                                         << tcu::TestLog::Message
2339                                         << "Program:\n"
2340                                         << "\tTotal program output vertices count per input patch: " << (tessGenLevel*tessGenLevel*2 * geometryVerticesPerPrimitive) << "\n"
2341                                         << "\tTotal program output primitive count per input patch: " << (tessGenLevel*tessGenLevel*2 * geometryPrimitivesOutPerPrimitive) << "\n"
2342                                         << tcu::TestLog::EndMessage;
2343                         }
2344                 }
2345
2346                 m_program = new glu::ShaderProgram(m_context.getRenderContext(), sources);
2347                 m_testCtx.getLog() << *m_program;
2348                 if (!m_program->isOk())
2349                         throw tcu::TestError("failed to build program");
2350         }
2351 }
2352
2353 void GridRenderCase::deinit (void)
2354 {
2355         delete m_program;
2356         m_program = DE_NULL;
2357
2358         if (m_texture)
2359         {
2360                 m_context.getRenderContext().getFunctions().deleteTextures(1, &m_texture);
2361                 m_texture = 0;
2362         }
2363 }
2364
2365 GridRenderCase::IterateResult GridRenderCase::iterate (void)
2366 {
2367         std::vector<tcu::Surface>       renderedLayers  (m_numLayers);
2368         bool                                            allLayersOk             = true;
2369
2370         for (int ndx = 0; ndx < m_numLayers; ++ndx)
2371                 renderedLayers[ndx].setSize(RENDER_SIZE, RENDER_SIZE);
2372
2373         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;
2374
2375         try
2376         {
2377                 renderTo(renderedLayers);
2378         }
2379         catch (const AllowedRenderFailureException& ex)
2380         {
2381                 // Got accepted failure
2382                 m_testCtx.getLog()
2383                         << tcu::TestLog::Message
2384                         << "Could not render, reason: " << ex.what() << "\n"
2385                         << "Failure is allowed."
2386                         << tcu::TestLog::EndMessage;
2387
2388                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2389                 return STOP;
2390         }
2391
2392         for (int ndx = 0; ndx < m_numLayers; ++ndx)
2393                 allLayersOk &= verifyResultLayer(ndx, renderedLayers[ndx]);
2394
2395         if (allLayersOk)
2396                 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2397         else
2398                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Image verification failed");
2399         return STOP;
2400 }
2401
2402 void GridRenderCase::renderTo (std::vector<tcu::Surface>& dst)
2403 {
2404         const glw::Functions&                   gl                                      = m_context.getRenderContext().getFunctions();
2405         const int                                               positionLocation        = gl.getAttribLocation(m_program->getProgram(), "a_position");
2406         const glu::VertexArray                  vao                                     (m_context.getRenderContext());
2407         de::MovePtr<glu::Framebuffer>   fbo;
2408
2409         if (positionLocation == -1)
2410                 throw tcu::TestError("Attribute a_position location was -1");
2411
2412         gl.viewport(0, 0, dst.front().getWidth(), dst.front().getHeight());
2413         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
2414         GLU_EXPECT_NO_ERROR(gl.getError(), "viewport");
2415
2416         gl.bindVertexArray(*vao);
2417         GLU_EXPECT_NO_ERROR(gl.getError(), "bind vao");
2418
2419         gl.useProgram(m_program->getProgram());
2420         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
2421
2422         gl.patchParameteri(GL_PATCH_VERTICES, 1);
2423         GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
2424
2425         gl.vertexAttrib4f(positionLocation, 0.0f, 0.0f, 0.0f, 1.0f);
2426
2427         if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
2428         {
2429                 // clear texture contents
2430                 {
2431                         glu::Framebuffer clearFbo(m_context.getRenderContext());
2432                         gl.bindFramebuffer(GL_FRAMEBUFFER, *clearFbo);
2433
2434                         for (int layerNdx = 0; layerNdx < m_numLayers; ++layerNdx)
2435                         {
2436                                 gl.framebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture, 0, layerNdx);
2437                                 gl.clear(GL_COLOR_BUFFER_BIT);
2438                         }
2439
2440                         GLU_EXPECT_NO_ERROR(gl.getError(), "clear tex contents");
2441                 }
2442
2443                 // create and bind layered fbo
2444
2445                 fbo = de::MovePtr<glu::Framebuffer>(new glu::Framebuffer(m_context.getRenderContext()));
2446
2447                 gl.bindFramebuffer(GL_FRAMEBUFFER, **fbo);
2448                 gl.framebufferTexture(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture, 0);
2449                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen fbo");
2450         }
2451         else
2452         {
2453                 // clear viewport
2454                 gl.clear(GL_COLOR_BUFFER_BIT);
2455         }
2456
2457         // draw
2458         {
2459                 glw::GLenum glerror;
2460
2461                 gl.drawArrays(GL_PATCHES, 0, 1);
2462
2463                 glerror = gl.getError();
2464                 if (glerror == GL_OUT_OF_MEMORY && (m_flags & FLAG_ALLOW_OUT_OF_MEMORY))
2465                         throw AllowedRenderFailureException("got GL_OUT_OF_MEMORY while drawing");
2466
2467                 GLU_EXPECT_NO_ERROR(glerror, "draw patches");
2468         }
2469
2470         // Read layers
2471
2472         if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
2473         {
2474                 glu::Framebuffer readFbo(m_context.getRenderContext());
2475                 gl.bindFramebuffer(GL_FRAMEBUFFER, *readFbo);
2476
2477                 for (int layerNdx = 0; layerNdx < m_numLayers; ++layerNdx)
2478                 {
2479                         gl.framebufferTextureLayer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, m_texture, 0, layerNdx);
2480                         glu::readPixels(m_context.getRenderContext(), 0, 0, dst[layerNdx].getAccess());
2481                         GLU_EXPECT_NO_ERROR(gl.getError(), "read pixels");
2482                 }
2483         }
2484         else
2485         {
2486                 glu::readPixels(m_context.getRenderContext(), 0, 0, dst.front().getAccess());
2487                 GLU_EXPECT_NO_ERROR(gl.getError(), "read pixels");
2488         }
2489 }
2490
2491 bool GridRenderCase::verifyResultLayer (int layerNdx, const tcu::Surface& image)
2492 {
2493         tcu::Surface    errorMask       (image.getWidth(), image.getHeight());
2494         bool                    foundError      = false;
2495
2496         tcu::clear(errorMask.getAccess(), tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f));
2497
2498         m_testCtx.getLog() << tcu::TestLog::Message << "Verifying output layer " << layerNdx  << tcu::TestLog::EndMessage;
2499
2500         for (int y = 0; y < image.getHeight(); ++y)
2501         for (int x = 0; x < image.getWidth(); ++x)
2502         {
2503                 const int               threshold       = 8;
2504                 const tcu::RGBA color           = image.getPixel(x, y);
2505
2506                 // Color must be a linear combination of green and yellow
2507                 if (color.getGreen() < 255 - threshold || color.getBlue() > threshold)
2508                 {
2509                         errorMask.setPixel(x, y, tcu::RGBA::red);
2510                         foundError = true;
2511                 }
2512         }
2513
2514         if (!foundError)
2515         {
2516                 m_testCtx.getLog()
2517                         << tcu::TestLog::Message << "Image valid." << tcu::TestLog::EndMessage
2518                         << tcu::TestLog::ImageSet("ImageVerification", "Image verification")
2519                         << tcu::TestLog::Image("Result", "Rendered result", image.getAccess())
2520                         << tcu::TestLog::EndImageSet;
2521                 return true;
2522         }
2523         else
2524         {
2525                 m_testCtx.getLog()
2526                         << tcu::TestLog::Message << "Image verification failed, found invalid pixels." << tcu::TestLog::EndMessage
2527                         << tcu::TestLog::ImageSet("ImageVerification", "Image verification")
2528                         << tcu::TestLog::Image("Result", "Rendered result", image.getAccess())
2529                         << tcu::TestLog::Image("ErrorMask", "Error mask", errorMask.getAccess())
2530                         << tcu::TestLog::EndImageSet;
2531                 return false;
2532         }
2533 }
2534
2535 const char* GridRenderCase::getVertexSource (void)
2536 {
2537         return s_positionVertexShader;
2538 }
2539
2540 const char* GridRenderCase::getFragmentSource (void)
2541 {
2542         return  "#version 310 es\n"
2543                         "flat in mediump vec4 v_color;\n"
2544                         "layout(location = 0) out mediump vec4 fragColor;\n"
2545                         "void main (void)\n"
2546                         "{\n"
2547                         "       fragColor = v_color;\n"
2548                         "}\n";
2549 }
2550
2551 std::string GridRenderCase::getTessellationControlSource (int tessLevel)
2552 {
2553         std::ostringstream buf;
2554
2555         buf <<  "#version 310 es\n"
2556                         "#extension GL_EXT_tessellation_shader : require\n"
2557                         "layout(vertices=1) out;\n"
2558                         "\n"
2559                         "void main()\n"
2560                         "{\n"
2561                         "       gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
2562                         "       gl_TessLevelOuter[0] = " << tessLevel << ".0;\n"
2563                         "       gl_TessLevelOuter[1] = " << tessLevel << ".0;\n"
2564                         "       gl_TessLevelOuter[2] = " << tessLevel << ".0;\n"
2565                         "       gl_TessLevelOuter[3] = " << tessLevel << ".0;\n"
2566                         "       gl_TessLevelInner[0] = " << tessLevel << ".0;\n"
2567                         "       gl_TessLevelInner[1] = " << tessLevel << ".0;\n"
2568                         "}\n";
2569
2570         return buf.str();
2571 }
2572
2573 std::string GridRenderCase::getTessellationEvaluationSource (int tessLevel)
2574 {
2575         std::ostringstream buf;
2576
2577         buf <<  "#version 310 es\n"
2578                         "#extension GL_EXT_tessellation_shader : require\n"
2579                         "layout(quads) in;\n"
2580                         "\n"
2581                         "out mediump ivec2 v_tessellationGridPosition;\n"
2582                         "\n"
2583                         "void main (void)\n"
2584                         "{\n";
2585
2586         if (m_flags & (FLAG_GEOMETRY_SCATTER_INSTANCES | FLAG_GEOMETRY_SCATTER_PRIMITIVES | FLAG_GEOMETRY_SCATTER_LAYERS))
2587                 buf <<  "       // Cover only a small area in a corner. The area will be expanded in geometry shader to cover whole viewport\n"
2588                                 "       gl_Position = vec4(gl_TessCoord.x * 0.3 - 1.0, gl_TessCoord.y * 0.3 - 1.0, 0.0, 1.0);\n";
2589         else
2590                 buf <<  "       // Fill the whole viewport\n"
2591                                 "       gl_Position = vec4(gl_TessCoord.x * 2.0 - 1.0, gl_TessCoord.y * 2.0 - 1.0, 0.0, 1.0);\n";
2592
2593         buf <<  "       // Calculate position in tessellation grid\n"
2594                         "       v_tessellationGridPosition = ivec2(round(gl_TessCoord.xy * float(" << tessLevel << ")));\n"
2595                         "}\n";
2596
2597         return buf.str();
2598 }
2599
2600 std::string GridRenderCase::getGeometryShaderSource (int numPrimitives, int numInstances, int tessLevel)
2601 {
2602         std::ostringstream buf;
2603
2604         buf     <<      "#version 310 es\n"
2605                         "#extension GL_EXT_geometry_shader : require\n"
2606                         "layout(triangles, invocations=" << numInstances << ") in;\n"
2607                         "layout(triangle_strip, max_vertices=" << ((m_flags & FLAG_GEOMETRY_SEPARATE_PRIMITIVES) ? (4 * numPrimitives) : (numPrimitives + 2)) << ") out;\n"
2608                         "\n"
2609                         "in mediump ivec2 v_tessellationGridPosition[];\n"
2610                         "flat out highp vec4 v_color;\n"
2611                         "\n"
2612                         "void main ()\n"
2613                         "{\n"
2614                         "       const float equalThreshold = 0.001;\n"
2615                         "       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"
2616                         "\n"
2617                         "       // Input triangle is generated from an axis-aligned rectangle by splitting it in half\n"
2618                         "       // Original rectangle can be found by finding the bounding AABB of the triangle\n"
2619                         "       vec4 aabb = vec4(min(gl_in[0].gl_Position.x, min(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
2620                         "                        min(gl_in[0].gl_Position.y, min(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)),\n"
2621                         "                        max(gl_in[0].gl_Position.x, max(gl_in[1].gl_Position.x, gl_in[2].gl_Position.x)),\n"
2622                         "                        max(gl_in[0].gl_Position.y, max(gl_in[1].gl_Position.y, gl_in[2].gl_Position.y)));\n"
2623                         "\n"
2624                         "       // Location in tessellation grid\n"
2625                         "       ivec2 gridPosition = ivec2(min(v_tessellationGridPosition[0], min(v_tessellationGridPosition[1], v_tessellationGridPosition[2])));\n"
2626                         "\n"
2627                         "       // Which triangle of the two that split the grid cell\n"
2628                         "       int numVerticesOnBottomEdge = 0;\n"
2629                         "       for (int ndx = 0; ndx < 3; ++ndx)\n"
2630                         "               if (abs(gl_in[ndx].gl_Position.y - aabb.w) < equalThreshold)\n"
2631                         "                       ++numVerticesOnBottomEdge;\n"
2632                         "       bool isBottomTriangle = numVerticesOnBottomEdge == 2;\n"
2633                         "\n";
2634
2635         if (m_flags & FLAG_GEOMETRY_SCATTER_PRIMITIVES)
2636         {
2637                 // scatter primitives
2638                 buf <<  "       // Draw grid cells\n"
2639                                 "       int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
2640                                 "       for (int ndx = 0; ndx < " << numPrimitives << "; ++ndx)\n"
2641                                 "       {\n"
2642                                 "               ivec2 dstGridSize = ivec2(" << tessLevel << " * " << numPrimitives << ", 2 * " << tessLevel << " * " << numInstances << ");\n"
2643                                 "               ivec2 dstGridNdx = ivec2(" << tessLevel << " * ndx + gridPosition.x, " << tessLevel << " * inputTriangleNdx + 2 * gridPosition.y + ndx * 127) % dstGridSize;\n"
2644                                 "               vec4 dstArea;\n"
2645                                 "               dstArea.x = float(dstGridNdx.x) / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n"
2646                                 "               dstArea.y = float(dstGridNdx.y) / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n"
2647                                 "               dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n"
2648                                 "               dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n"
2649                                 "\n"
2650                                 "               vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
2651                                 "               vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
2652                                 "               vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n"
2653                                 "\n"
2654                                 "               gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n"
2655                                 "               v_color = outputColor;\n"
2656                                 "               EmitVertex();\n"
2657                                 "\n"
2658                                 "               gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n"
2659                                 "               v_color = outputColor;\n"
2660                                 "               EmitVertex();\n"
2661                                 "\n"
2662                                 "               gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n"
2663                                 "               v_color = outputColor;\n"
2664                                 "               EmitVertex();\n"
2665                                 "\n"
2666                                 "               gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n"
2667                                 "               v_color = outputColor;\n"
2668                                 "               EmitVertex();\n"
2669                                 "               EndPrimitive();\n"
2670                                 "       }\n";
2671         }
2672         else if (m_flags & FLAG_GEOMETRY_SCATTER_LAYERS)
2673         {
2674                 // Number of subrectangle instances = num layers
2675                 DE_ASSERT(m_numLayers == numInstances * 2);
2676
2677                 buf <<  "       // Draw grid cells, send each primitive to a separate layer\n"
2678                                 "       int baseLayer = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
2679                                 "       for (int ndx = 0; ndx < " << numPrimitives << "; ++ndx)\n"
2680                                 "       {\n"
2681                                 "               ivec2 dstGridSize = ivec2(" << tessLevel << " * " << numPrimitives << ", " << tessLevel << ");\n"
2682                                 "               ivec2 dstGridNdx = ivec2((gridPosition.x * " << numPrimitives << " * 7 + ndx)*13, (gridPosition.y * 127 + ndx) * 19) % dstGridSize;\n"
2683                                 "               vec4 dstArea;\n"
2684                                 "               dstArea.x = float(dstGridNdx.x) / float(dstGridSize.x) * 2.0 - 1.0 - gapOffset;\n"
2685                                 "               dstArea.y = float(dstGridNdx.y) / float(dstGridSize.y) * 2.0 - 1.0 - gapOffset;\n"
2686                                 "               dstArea.z = float(dstGridNdx.x+1) / float(dstGridSize.x) * 2.0 - 1.0 + gapOffset;\n"
2687                                 "               dstArea.w = float(dstGridNdx.y+1) / float(dstGridSize.y) * 2.0 - 1.0 + gapOffset;\n"
2688                                 "\n"
2689                                 "               vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
2690                                 "               vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
2691                                 "               vec4 outputColor = (((dstGridNdx.y + dstGridNdx.x) % 2) == 0) ? (green) : (yellow);\n"
2692                                 "\n"
2693                                 "               gl_Position = vec4(dstArea.x, dstArea.y, 0.0, 1.0);\n"
2694                                 "               v_color = outputColor;\n"
2695                                 "               gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
2696                                 "               EmitVertex();\n"
2697                                 "\n"
2698                                 "               gl_Position = vec4(dstArea.x, dstArea.w, 0.0, 1.0);\n"
2699                                 "               v_color = outputColor;\n"
2700                                 "               gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
2701                                 "               EmitVertex();\n"
2702                                 "\n"
2703                                 "               gl_Position = vec4(dstArea.z, dstArea.y, 0.0, 1.0);\n"
2704                                 "               v_color = outputColor;\n"
2705                                 "               gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
2706                                 "               EmitVertex();\n"
2707                                 "\n"
2708                                 "               gl_Position = vec4(dstArea.z, dstArea.w, 0.0, 1.0);\n"
2709                                 "               v_color = outputColor;\n"
2710                                 "               gl_Layer = ((baseLayer + ndx) * 11) % " << m_numLayers << ";\n"
2711                                 "               EmitVertex();\n"
2712                                 "               EndPrimitive();\n"
2713                                 "       }\n";
2714         }
2715         else
2716         {
2717                 if (m_flags & FLAG_GEOMETRY_SCATTER_INSTANCES)
2718                 {
2719                         buf <<  "       // Scatter slices\n"
2720                                         "       int inputTriangleNdx = gl_InvocationID * 2 + ((isBottomTriangle) ? (1) : (0));\n"
2721                                         "       ivec2 srcSliceNdx = ivec2(gridPosition.x, gridPosition.y * " << (numInstances*2) << " + inputTriangleNdx);\n"
2722                                         "       ivec2 dstSliceNdx = ivec2(7 * srcSliceNdx.x, 127 * srcSliceNdx.y) % ivec2(" << tessLevel << ", " << tessLevel << " * " << (numInstances*2) << ");\n"
2723                                         "\n"
2724                                         "       // Draw slice to the dstSlice slot\n"
2725                                         "       vec4 outputSliceArea;\n"
2726                                         "       outputSliceArea.x = float(dstSliceNdx.x) / float(" << tessLevel << ") * 2.0 - 1.0 - gapOffset;\n"
2727                                         "       outputSliceArea.y = float(dstSliceNdx.y) / float(" << (tessLevel * numInstances * 2) << ") * 2.0 - 1.0 - gapOffset;\n"
2728                                         "       outputSliceArea.z = float(dstSliceNdx.x+1) / float(" << tessLevel << ") * 2.0 - 1.0 + gapOffset;\n"
2729                                         "       outputSliceArea.w = float(dstSliceNdx.y+1) / float(" << (tessLevel * numInstances * 2) << ") * 2.0 - 1.0 + gapOffset;\n";
2730                 }
2731                 else
2732                 {
2733                         buf <<  "       // Fill the input area with slices\n"
2734                                         "       // Upper triangle produces slices only to the upper half of the quad and vice-versa\n"
2735                                         "       float triangleOffset = (isBottomTriangle) ? ((aabb.w + aabb.y) / 2.0) : (aabb.y);\n"
2736                                         "       // Each slice is a invocation\n"
2737                                         "       float sliceHeight = (aabb.w - aabb.y) / float(2 * " << numInstances << ");\n"
2738                                         "       float invocationOffset = float(gl_InvocationID) * sliceHeight;\n"
2739                                         "\n"
2740                                         "       vec4 outputSliceArea;\n"
2741                                         "       outputSliceArea.x = aabb.x - gapOffset;\n"
2742                                         "       outputSliceArea.y = triangleOffset + invocationOffset - gapOffset;\n"
2743                                         "       outputSliceArea.z = aabb.z + gapOffset;\n"
2744                                         "       outputSliceArea.w = triangleOffset + invocationOffset + sliceHeight + gapOffset;\n";
2745                 }
2746
2747                 buf <<  "\n"
2748                                 "       // Draw slice\n"
2749                                 "       for (int ndx = 0; ndx < " << ((numPrimitives+2)/2) << "; ++ndx)\n"
2750                                 "       {\n"
2751                                 "               vec4 green = vec4(0.0, 1.0, 0.0, 1.0);\n"
2752                                 "               vec4 yellow = vec4(1.0, 1.0, 0.0, 1.0);\n"
2753                                 "               vec4 outputColor = (((gl_InvocationID + ndx) % 2) == 0) ? (green) : (yellow);\n"
2754                                 "               float xpos = mix(outputSliceArea.x, outputSliceArea.z, float(ndx) / float(" << (numPrimitives/2) << "));\n"
2755                                 "\n"
2756                                 "               gl_Position = vec4(xpos, outputSliceArea.y, 0.0, 1.0);\n"
2757                                 "               v_color = outputColor;\n"
2758                                 "               EmitVertex();\n"
2759                                 "\n"
2760                                 "               gl_Position = vec4(xpos, outputSliceArea.w, 0.0, 1.0);\n"
2761                                 "               v_color = outputColor;\n"
2762                                 "               EmitVertex();\n"
2763                                 "       }\n";
2764         }
2765
2766         buf <<  "}\n";
2767
2768         return buf.str();
2769 }
2770
2771 class FeedbackRecordVariableSelectionCase : public TestCase
2772 {
2773 public:
2774                                                 FeedbackRecordVariableSelectionCase             (Context& context, const char* name, const char* description);
2775                                                 ~FeedbackRecordVariableSelectionCase    (void);
2776
2777 private:
2778         void                            init                                                                    (void);
2779         void                            deinit                                                                  (void);
2780         IterateResult           iterate                                                                 (void);
2781
2782         const char*                     getVertexSource                                                 (void);
2783         const char*                     getFragmentSource                                               (void);
2784         const char*                     getTessellationControlSource                    (void);
2785         const char*                     getTessellationEvaluationSource                 (void);
2786         const char*                     getGeometrySource                                               (void);
2787
2788         glu::ShaderProgram*     m_program;
2789         deUint32                        m_xfbBuf;
2790 };
2791
2792 FeedbackRecordVariableSelectionCase::FeedbackRecordVariableSelectionCase (Context& context, const char* name, const char* description)
2793         : TestCase      (context, name, description)
2794         , m_program     (DE_NULL)
2795         , m_xfbBuf      (0)
2796 {
2797 }
2798
2799 FeedbackRecordVariableSelectionCase::~FeedbackRecordVariableSelectionCase (void)
2800 {
2801         deinit();
2802 }
2803
2804 void FeedbackRecordVariableSelectionCase::init (void)
2805 {
2806         if (!m_context.getContextInfo().isExtensionSupported("GL_EXT_tessellation_shader") ||
2807                 !m_context.getContextInfo().isExtensionSupported("GL_EXT_geometry_shader"))
2808                 throw tcu::NotSupportedError("Test requires GL_EXT_tessellation_shader and GL_EXT_geometry_shader extensions");
2809
2810         m_testCtx.getLog() << tcu::TestLog::Message << "Declaring multiple output variables with the same name in multiple shader stages. Capturing the value of the varying using transform feedback." << tcu::TestLog::EndMessage;
2811
2812         // gen feedback buffer fit for 1 triangle (4 components)
2813         {
2814                 static const tcu::Vec4 initialData[3] =
2815                 {
2816                         tcu::Vec4(-1.0f, -1.0f, -1.0f, -1.0f),
2817                         tcu::Vec4(-1.0f, -1.0f, -1.0f, -1.0f),
2818                         tcu::Vec4(-1.0f, -1.0f, -1.0f, -1.0f),
2819                 };
2820
2821                 const glw::Functions& gl = m_context.getRenderContext().getFunctions();
2822
2823                 m_testCtx.getLog() << tcu::TestLog::Message << "Creating buffer for transform feedback. Allocating storage for one triangle. Filling with -1.0" << tcu::TestLog::EndMessage;
2824
2825                 gl.genBuffers(1, &m_xfbBuf);
2826                 gl.bindBuffer(GL_TRANSFORM_FEEDBACK_BUFFER, m_xfbBuf);
2827                 gl.bufferData(GL_TRANSFORM_FEEDBACK_BUFFER, (int)(sizeof(tcu::Vec4[3])), initialData, GL_DYNAMIC_READ);
2828                 GLU_EXPECT_NO_ERROR(gl.getError(), "gen xfb buf");
2829         }
2830
2831         // gen shader
2832         m_program = new glu::ShaderProgram(m_context.getRenderContext(), glu::ProgramSources()
2833                                                                                                                                          << glu::VertexSource(getVertexSource())
2834                                                                                                                                          << glu::FragmentSource(getFragmentSource())
2835                                                                                                                                          << glu::TessellationControlSource(getTessellationControlSource())
2836                                                                                                                                          << glu::TessellationEvaluationSource(getTessellationEvaluationSource())
2837                                                                                                                                          << glu::GeometrySource(getGeometrySource())
2838                                                                                                                                          << glu::TransformFeedbackMode(GL_INTERLEAVED_ATTRIBS)
2839                                                                                                                                          << glu::TransformFeedbackVarying("tf_feedback"));
2840         m_testCtx.getLog() << *m_program;
2841
2842         if (!m_program->isOk())
2843                 throw tcu::TestError("could not build program");
2844 }
2845
2846 void FeedbackRecordVariableSelectionCase::deinit (void)
2847 {
2848         delete m_program;
2849         m_program = DE_NULL;
2850
2851         if (m_xfbBuf)
2852         {
2853                 m_context.getRenderContext().getFunctions().deleteBuffers(1, &m_xfbBuf);
2854                 m_xfbBuf = 0;
2855         }
2856 }
2857
2858 FeedbackRecordVariableSelectionCase::IterateResult FeedbackRecordVariableSelectionCase::iterate (void)
2859 {
2860         const glw::Functions&   gl              = m_context.getRenderContext().getFunctions();
2861         const int                               posLoc  = gl.getAttribLocation(m_program->getProgram(), "a_position");
2862         const glu::VertexArray  vao             (m_context.getRenderContext());
2863
2864         if (posLoc == -1)
2865                 throw tcu::TestError("a_position attribute location was -1");
2866
2867         m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass");
2868
2869         m_testCtx.getLog() << tcu::TestLog::Message << "Rendering a patch of size 3." << tcu::TestLog::EndMessage;
2870
2871         // Render and feed back
2872
2873         gl.viewport(0, 0, 1, 1);
2874         gl.clearColor(0.0f, 0.0f, 0.0f, 1.0f);
2875         gl.clear(GL_COLOR_BUFFER_BIT);
2876         GLU_EXPECT_NO_ERROR(gl.getError(), "clear");
2877
2878         gl.bindVertexArray(*vao);
2879         GLU_EXPECT_NO_ERROR(gl.getError(), "bindVertexArray");
2880
2881         gl.vertexAttrib4f(posLoc, 0.0f, 0.0f, 0.0f, 1.0f);
2882         GLU_EXPECT_NO_ERROR(gl.getError(), "vertexAttrib4f");
2883
2884         gl.useProgram(m_program->getProgram());
2885         GLU_EXPECT_NO_ERROR(gl.getError(), "use program");
2886
2887         gl.patchParameteri(GL_PATCH_VERTICES, 3);
2888         GLU_EXPECT_NO_ERROR(gl.getError(), "set patch param");
2889
2890         gl.bindBufferBase(GL_TRANSFORM_FEEDBACK_BUFFER, 0, m_xfbBuf);
2891         GLU_EXPECT_NO_ERROR(gl.getError(), "bind xfb buf");
2892
2893         gl.beginTransformFeedback(GL_TRIANGLES);
2894         GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
2895
2896         gl.drawArrays(GL_PATCHES, 0, 3);
2897         GLU_EXPECT_NO_ERROR(gl.getError(), "drawArrays");
2898
2899         gl.endTransformFeedback();
2900         GLU_EXPECT_NO_ERROR(gl.getError(), "beginTransformFeedback");
2901
2902         m_testCtx.getLog() << tcu::TestLog::Message << "Verifying the value of tf_feedback using transform feedback, expecting (3.0, 3.0, 3.0, 3.0)." << tcu::TestLog::EndMessage;
2903
2904         // Read back result (one triangle)
2905         {
2906                 tcu::Vec4       feedbackValues[3];
2907                 const void* mapPtr                              = gl.mapBufferRange(GL_TRANSFORM_FEEDBACK_BUFFER, 0, (int)sizeof(feedbackValues), GL_MAP_READ_BIT);
2908                 GLU_EXPECT_NO_ERROR(gl.getError(), "mapBufferRange");
2909
2910                 if (mapPtr == DE_NULL)
2911                         throw tcu::TestError("mapBufferRange returned null");
2912
2913                 deMemcpy(feedbackValues, mapPtr, sizeof(feedbackValues));
2914
2915                 if (gl.unmapBuffer(GL_TRANSFORM_FEEDBACK_BUFFER) != GL_TRUE)
2916                         throw tcu::TestError("unmapBuffer did not return TRUE");
2917
2918                 for (int ndx = 0; ndx < 3; ++ndx)
2919                 {
2920                         if (!tcu::boolAll(tcu::lessThan(tcu::abs(feedbackValues[ndx] - tcu::Vec4(3.0f)), tcu::Vec4(0.001f))))
2921                         {
2922                                 m_testCtx.getLog() << tcu::TestLog::Message << "Feedback vertex " << ndx << ": expected (3.0, 3.0, 3.0, 3.0), got " << feedbackValues[ndx] << tcu::TestLog::EndMessage;
2923                                 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "got unexpected feedback results");
2924                         }
2925                 }
2926         }
2927
2928         return STOP;
2929 }
2930
2931 const char* FeedbackRecordVariableSelectionCase::getVertexSource (void)
2932 {
2933         return  "#version 310 es\n"
2934                         "in highp vec4 a_position;\n"
2935                         "out highp vec4 tf_feedback;\n"
2936                         "void main()\n"
2937                         "{\n"
2938                         "       gl_Position = a_position;\n"
2939                         "       tf_feedback = vec4(1.0, 1.0, 1.0, 1.0);\n"
2940                         "}\n";
2941 }
2942
2943 const char* FeedbackRecordVariableSelectionCase::getFragmentSource (void)
2944 {
2945         return s_whiteOutputFragmentShader;
2946 }
2947
2948 const char* FeedbackRecordVariableSelectionCase::getTessellationControlSource (void)
2949 {
2950         return  "#version 310 es\n"
2951                         "#extension GL_EXT_tessellation_shader : require\n"
2952                         "layout(vertices=3) out;\n"
2953                         "void main()\n"
2954                         "{\n"
2955                         "       gl_out[gl_InvocationID].gl_Position = gl_in[gl_InvocationID].gl_Position;\n"
2956                         "       gl_TessLevelOuter[0] = 1.0;\n"
2957                         "       gl_TessLevelOuter[1] = 1.0;\n"
2958                         "       gl_TessLevelOuter[2] = 1.0;\n"
2959                         "       gl_TessLevelInner[0] = 1.0;\n"
2960                         "}\n";
2961 }
2962
2963 const char* FeedbackRecordVariableSelectionCase::getTessellationEvaluationSource (void)
2964 {
2965         return  "#version 310 es\n"
2966                         "#extension GL_EXT_tessellation_shader : require\n"
2967                         "layout(triangles) in;\n"
2968                         "out highp vec4 tf_feedback;\n"
2969                         "void main()\n"
2970                         "{\n"
2971                         "       gl_Position = gl_in[0].gl_Position * gl_TessCoord.x + gl_in[1].gl_Position * gl_TessCoord.y + gl_in[2].gl_Position * gl_TessCoord.z;\n"
2972                         "       tf_feedback = vec4(2.0, 2.0, 2.0, 2.0);\n"
2973                         "}\n";
2974 }
2975
2976 const char* FeedbackRecordVariableSelectionCase::getGeometrySource (void)
2977 {
2978         return  "#version 310 es\n"
2979                         "#extension GL_EXT_geometry_shader : require\n"
2980                         "layout (triangles) in;\n"
2981                         "layout (triangle_strip, max_vertices=3) out;\n"
2982                         "out highp vec4 tf_feedback;\n"
2983                         "void main()\n"
2984                         "{\n"
2985                         "       for (int ndx = 0; ndx < 3; ++ndx)\n"
2986                         "       {\n"
2987                         "               gl_Position = gl_in[ndx].gl_Position + vec4(float(ndx), float(ndx)*float(ndx), 0.0, 0.0);\n"
2988                         "               tf_feedback = vec4(3.0, 3.0, 3.0, 3.0);\n"
2989                         "               EmitVertex();\n"
2990                         "       }\n"
2991                         "       EndPrimitive();\n"
2992                         "}\n";
2993 }
2994
2995 } // anonymous
2996
2997 TessellationGeometryInteractionTests::TessellationGeometryInteractionTests (Context& context)
2998         : TestCaseGroup(context, "tessellation_geometry_interaction", "Tessellation and geometry shader interaction tests")
2999 {
3000 }
3001
3002 TessellationGeometryInteractionTests::~TessellationGeometryInteractionTests (void)
3003 {
3004 }
3005
3006 void TessellationGeometryInteractionTests::init (void)
3007 {
3008         tcu::TestCaseGroup* const renderGroup           = new tcu::TestCaseGroup(m_testCtx, "render",           "Various render tests");
3009         tcu::TestCaseGroup* const feedbackGroup         = new tcu::TestCaseGroup(m_testCtx, "feedback",         "Test transform feedback");
3010         tcu::TestCaseGroup* const pointSizeGroup        = new tcu::TestCaseGroup(m_testCtx, "point_size",       "Test point size");
3011
3012         addChild(renderGroup);
3013         addChild(feedbackGroup);
3014         addChild(pointSizeGroup);
3015
3016         // .render
3017         {
3018                 tcu::TestCaseGroup* const passthroughGroup      = new tcu::TestCaseGroup(m_testCtx, "passthrough",      "Render various types with either passthrough geometry or tessellation shader");
3019                 tcu::TestCaseGroup* const limitGroup            = new tcu::TestCaseGroup(m_testCtx, "limits",           "Render with properties near their limits");
3020                 tcu::TestCaseGroup* const scatterGroup          = new tcu::TestCaseGroup(m_testCtx, "scatter",          "Scatter output primitives");
3021
3022                 renderGroup->addChild(passthroughGroup);
3023                 renderGroup->addChild(limitGroup);
3024                 renderGroup->addChild(scatterGroup);
3025
3026                 // .passthrough
3027                 {
3028                         // tessellate_tris_passthrough_geometry_no_change
3029                         // tessellate_quads_passthrough_geometry_no_change
3030                         // tessellate_isolines_passthrough_geometry_no_change
3031                         passthroughGroup->addChild(new IdentityGeometryShaderCase(m_context, "tessellate_tris_passthrough_geometry_no_change",          "Passthrough geometry shader has no effect", IdentityGeometryShaderCase::CASE_TRIANGLES));
3032                         passthroughGroup->addChild(new IdentityGeometryShaderCase(m_context, "tessellate_quads_passthrough_geometry_no_change",         "Passthrough geometry shader has no effect", IdentityGeometryShaderCase::CASE_QUADS));
3033                         passthroughGroup->addChild(new IdentityGeometryShaderCase(m_context, "tessellate_isolines_passthrough_geometry_no_change",      "Passthrough geometry shader has no effect", IdentityGeometryShaderCase::CASE_ISOLINES));
3034
3035                         // passthrough_tessellation_geometry_shade_triangles_no_change
3036                         // passthrough_tessellation_geometry_shade_lines_no_change
3037                         passthroughGroup->addChild(new IdentityTessellationShaderCase(m_context, "passthrough_tessellation_geometry_shade_triangles_no_change", "Passthrough tessellation shader has no effect", IdentityTessellationShaderCase::CASE_TRIANGLES));
3038                         passthroughGroup->addChild(new IdentityTessellationShaderCase(m_context, "passthrough_tessellation_geometry_shade_lines_no_change",             "Passthrough tessellation shader has no effect", IdentityTessellationShaderCase::CASE_ISOLINES));
3039                 }
3040
3041                 // .limits
3042                 {
3043                         static const struct LimitCaseDef
3044                         {
3045                                 const char*     name;
3046                                 const char*     desc;
3047                                 int                     flags;
3048                         } cases[] =
3049                         {
3050                                 // Test single limit
3051                                 {
3052                                         "output_required_max_tessellation",
3053                                         "Minimum maximum tessellation level",
3054                                         GridRenderCase::FLAG_TESSELLATION_MAX_SPEC
3055                                 },
3056                                 {
3057                                         "output_implementation_max_tessellation",
3058                                         "Maximum tessellation level supported by the implementation",
3059                                         GridRenderCase::FLAG_TESSELLATION_MAX_IMPLEMENTATION
3060                                 },
3061                                 {
3062                                         "output_required_max_geometry",
3063                                         "Output minimum maximum number of vertices the geometry shader",
3064                                         GridRenderCase::FLAG_GEOMETRY_MAX_SPEC
3065                                 },
3066                                 {
3067                                         "output_implementation_max_geometry",
3068                                         "Output maximum number of vertices in the geometry shader supported by the implementation",
3069                                         GridRenderCase::FLAG_GEOMETRY_MAX_IMPLEMENTATION
3070                                 },
3071                                 {
3072                                         "output_required_max_invocations",
3073                                         "Minimum maximum number of geometry shader invocations",
3074                                         GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_SPEC
3075                                 },
3076                                 {
3077                                         "output_implementation_max_invocations",
3078                                         "Maximum number of geometry shader invocations supported by the implementation",
3079                                         GridRenderCase::FLAG_GEOMETRY_INVOCATIONS_MAX_IMPLEMENTATION
3080                                 },
3081                         };
3082
3083                         for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(cases); ++ndx)
3084                                 limitGroup->addChild(new GridRenderCase(m_context, cases[ndx].name, cases[ndx].desc, cases[ndx].flags));
3085                 }
3086
3087                 // .scatter
3088                 {
3089                         scatterGroup->addChild(new GridRenderCase(m_context,
3090                                                                                                           "geometry_scatter_instances",
3091                                                                                                           "Each geometry shader instance outputs its primitives far from other instances of the same execution",
3092                                                                                                           GridRenderCase::FLAG_GEOMETRY_SCATTER_INSTANCES));
3093                         scatterGroup->addChild(new GridRenderCase(m_context,
3094                                                                                                           "geometry_scatter_primitives",
3095                                                                                                           "Each geometry shader instance outputs its primitives far from other primitives of the same instance",
3096                                                                                                           GridRenderCase::FLAG_GEOMETRY_SCATTER_PRIMITIVES | GridRenderCase::FLAG_GEOMETRY_SEPARATE_PRIMITIVES));
3097                         scatterGroup->addChild(new GridRenderCase(m_context,
3098                                                                                                           "geometry_scatter_layers",
3099                                                                                                           "Each geometry shader instance outputs its primitives to multiple layers and far from other primitives of the same instance",
3100                                                                                                           GridRenderCase::FLAG_GEOMETRY_SCATTER_LAYERS | GridRenderCase::FLAG_GEOMETRY_SEPARATE_PRIMITIVES));
3101                 }
3102         }
3103
3104         // .feedback
3105         {
3106                 static const struct PrimitiveCaseConfig
3107                 {
3108                         const char*                                                                                     name;
3109                         const char*                                                                                     description;
3110                         FeedbackPrimitiveTypeCase::TessellationOutputType       tessellationOutput;
3111                         FeedbackPrimitiveTypeCase::TessellationPointMode        tessellationPointMode;
3112                         FeedbackPrimitiveTypeCase::GeometryOutputType           geometryOutputType;
3113                 } caseConfigs[] =
3114                 {
3115                         // tess output triangles -> geo input triangles, output points
3116                         {
3117                                 "tessellation_output_triangles_geometry_output_points",
3118                                 "Tessellation outputs triangles, geometry outputs points",
3119                                 FeedbackPrimitiveTypeCase::TESSELLATION_OUT_TRIANGLES,
3120                                 FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_OFF,
3121                                 FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_POINTS
3122                         },
3123
3124                         // tess output quads <-> geo input triangles, output points
3125                         {
3126                                 "tessellation_output_quads_geometry_output_points",
3127                                 "Tessellation outputs quads, geometry outputs points",
3128                                 FeedbackPrimitiveTypeCase::TESSELLATION_OUT_QUADS,
3129                                 FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_OFF,
3130                                 FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_POINTS
3131                         },
3132
3133                         // tess output isolines <-> geo input lines, output points
3134                         {
3135                                 "tessellation_output_isolines_geometry_output_points",
3136                                 "Tessellation outputs isolines, geometry outputs points",
3137                                 FeedbackPrimitiveTypeCase::TESSELLATION_OUT_ISOLINES,
3138                                 FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_OFF,
3139                                 FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_POINTS
3140                         },
3141
3142                         // tess output triangles, point_mode <-> geo input points, output lines
3143                         {
3144                                 "tessellation_output_triangles_point_mode_geometry_output_lines",
3145                                 "Tessellation outputs triangles in point mode, geometry outputs lines",
3146                                 FeedbackPrimitiveTypeCase::TESSELLATION_OUT_TRIANGLES,
3147                                 FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_ON,
3148                                 FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_LINES
3149                         },
3150
3151                         // tess output quads, point_mode <-> geo input points, output lines
3152                         {
3153                                 "tessellation_output_quads_point_mode_geometry_output_lines",
3154                                 "Tessellation outputs quads in point mode, geometry outputs lines",
3155                                 FeedbackPrimitiveTypeCase::TESSELLATION_OUT_QUADS,
3156                                 FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_ON,
3157                                 FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_LINES
3158                         },
3159
3160                         // tess output isolines, point_mode <-> geo input points, output triangles
3161                         {
3162                                 "tessellation_output_isolines_point_mode_geometry_output_triangles",
3163                                 "Tessellation outputs isolines in point mode, geometry outputs triangles",
3164                                 FeedbackPrimitiveTypeCase::TESSELLATION_OUT_ISOLINES,
3165                                 FeedbackPrimitiveTypeCase::TESSELLATION_POINTMODE_ON,
3166                                 FeedbackPrimitiveTypeCase::GEOMETRY_OUTPUT_TRIANGLES
3167                         },
3168                 };
3169
3170                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(caseConfigs); ++ndx)
3171                 {
3172                         feedbackGroup->addChild(new FeedbackPrimitiveTypeCase(m_context,
3173                                                                                                                                   caseConfigs[ndx].name,
3174                                                                                                                                   caseConfigs[ndx].description,
3175                                                                                                                                   caseConfigs[ndx].tessellationOutput,
3176                                                                                                                                   caseConfigs[ndx].tessellationPointMode,
3177                                                                                                                                   caseConfigs[ndx].geometryOutputType));
3178                 }
3179
3180                 feedbackGroup->addChild(new FeedbackRecordVariableSelectionCase(m_context, "record_variable_selection", "Record a variable that has been declared as an output variable in multiple shader stages"));
3181         }
3182
3183         // .point_size
3184         {
3185                 static const int caseFlags[] =
3186                 {
3187                         PointSizeCase::FLAG_VERTEX_SET,
3188                                                                                                 PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET,
3189                                                                                                                                                                                                                 PointSizeCase::FLAG_GEOMETRY_SET,
3190                         PointSizeCase::FLAG_VERTEX_SET  |       PointSizeCase::FLAG_TESSELLATION_CONTROL_SET,
3191                         PointSizeCase::FLAG_VERTEX_SET  |       PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET,
3192                         PointSizeCase::FLAG_VERTEX_SET  |       PointSizeCase::FLAG_TESSELLATION_DONT_SET,
3193                         PointSizeCase::FLAG_VERTEX_SET  |                                                                                                                       PointSizeCase::FLAG_GEOMETRY_SET,
3194                         PointSizeCase::FLAG_VERTEX_SET  |       PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET         |       PointSizeCase::FLAG_GEOMETRY_SET,
3195                         PointSizeCase::FLAG_VERTEX_SET  |       PointSizeCase::FLAG_TESSELLATION_ADD                            |       PointSizeCase::FLAG_GEOMETRY_ADD,
3196                         PointSizeCase::FLAG_VERTEX_SET  |       PointSizeCase::FLAG_TESSELLATION_EVALUATION_SET         |       PointSizeCase::FLAG_GEOMETRY_DONT_SET,
3197                 };
3198
3199                 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(caseFlags); ++ndx)
3200                 {
3201                         const std::string name = PointSizeCase::genTestCaseName(caseFlags[ndx]);
3202                         const std::string desc = PointSizeCase::genTestCaseDescription(caseFlags[ndx]);
3203
3204                         pointSizeGroup->addChild(new PointSizeCase(m_context, name.c_str(), desc.c_str(), caseFlags[ndx]));
3205                 }
3206         }
3207 }
3208
3209 } // Functional
3210 } // gles31
3211 } // deqp