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 Multisample interpolation tests 22 *//*--------------------------------------------------------------------*/ 23 24 #include "es31fShaderMultisampleInterpolationTests.hpp" 25 #include "es31fMultisampleShaderRenderCase.hpp" 26 #include "tcuTestLog.hpp" 27 #include "tcuRGBA.hpp" 28 #include "tcuSurface.hpp" 29 #include "tcuStringTemplate.hpp" 30 #include "tcuRenderTarget.hpp" 31 #include "gluContextInfo.hpp" 32 #include "gluShaderProgram.hpp" 33 #include "gluRenderContext.hpp" 34 #include "glwFunctions.hpp" 35 #include "glwEnums.hpp" 36 #include "deArrayUtil.hpp" 37 #include "deStringUtil.hpp" 38 #include "deMath.h" 39 40 #include <map> 41 42 namespace deqp 43 { 44 namespace gles31 45 { 46 namespace Functional 47 { 48 namespace 49 { 50 51 static std::string specializeShader(const std::string& shaderSource, const glu::ContextType& contextType) 52 { 53 const bool supportsES32 = glu::contextSupports(contextType, glu::ApiType::es(3, 2)); 54 55 std::map<std::string, std::string> args; 56 args["GLSL_VERSION_DECL"] = glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(contextType)); 57 args["GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION"] = supportsES32 ? "" : "#extension GL_OES_shader_multisample_interpolation : require\n"; 58 args["GLSL_EXT_SAMPLE_VARIABLES"] = supportsES32 ? "" : "#extension GL_OES_sample_variables : require\n"; 59 60 return tcu::StringTemplate(shaderSource).specialize(args); 61 } 62 63 static bool verifyGreenImage (const tcu::Surface& image, tcu::TestLog& log) 64 { 65 bool error = false; 66 67 log << tcu::TestLog::Message << "Verifying result image, expecting green." << tcu::TestLog::EndMessage; 68 69 // all pixels must be green 70 71 for (int y = 0; y < image.getHeight(); ++y) 72 for (int x = 0; x < image.getWidth(); ++x) 73 { 74 const tcu::RGBA color = image.getPixel(x, y); 75 const int greenThreshold = 8; 76 77 if (color.getRed() > 0 || color.getGreen() < 255-greenThreshold || color.getBlue() > 0) 78 error = true; 79 } 80 81 if (error) 82 log << tcu::TestLog::Image("ResultImage", "Result Image", image.getAccess()) 83 << tcu::TestLog::Message 84 << "Image verification failed." 85 << tcu::TestLog::EndMessage; 86 else 87 log << tcu::TestLog::Image("ResultImage", "Result Image", image.getAccess()) 88 << tcu::TestLog::Message 89 << "Image verification passed." 90 << tcu::TestLog::EndMessage; 91 92 return !error; 93 } 94 95 class MultisampleShadeCountRenderCase : public MultisampleShaderRenderUtil::MultisampleRenderCase 96 { 97 public: 98 MultisampleShadeCountRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target); 99 virtual ~MultisampleShadeCountRenderCase (void); 100 101 void init (void); 102 103 private: 104 enum 105 { 106 RENDER_SIZE = 128 107 }; 108 109 virtual std::string getIterationDescription (int iteration) const; 110 bool verifyImage (const tcu::Surface& resultImage); 111 }; 112 113 MultisampleShadeCountRenderCase::MultisampleShadeCountRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target) 114 : MultisampleShaderRenderUtil::MultisampleRenderCase(context, name, description, numSamples, target, RENDER_SIZE, MultisampleShaderRenderUtil::MultisampleRenderCase::FLAG_PER_ITERATION_SHADER) 115 { 116 m_numIterations = -1; // must be set by deriving class 117 } 118 119 MultisampleShadeCountRenderCase::~MultisampleShadeCountRenderCase (void) 120 { 121 } 122 123 void MultisampleShadeCountRenderCase::init (void) 124 { 125 // requirements 126 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 127 TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation extension"); 128 129 MultisampleShaderRenderUtil::MultisampleRenderCase::init(); 130 } 131 132 std::string MultisampleShadeCountRenderCase::getIterationDescription (int iteration) const 133 { 134 // must be overriden 135 DE_UNREF(iteration); 136 DE_ASSERT(false); 137 return ""; 138 } 139 140 bool MultisampleShadeCountRenderCase::verifyImage (const tcu::Surface& resultImage) 141 { 142 const bool isSingleSampleTarget = (m_renderTarget != TARGET_DEFAULT && m_numRequestedSamples == 0) || (m_renderTarget == TARGET_DEFAULT && m_context.getRenderTarget().getNumSamples() <= 1); 143 const int numShadesRequired = (isSingleSampleTarget) ? (2) : (m_numTargetSamples + 1); 144 const int rareThreshold = 100; 145 int rareCount = 0; 146 std::map<deUint32, int> shadeFrequency; 147 148 m_testCtx.getLog() 149 << tcu::TestLog::Image("ResultImage", "Result Image", resultImage.getAccess()) 150 << tcu::TestLog::Message 151 << "Verifying image has (at least) " << numShadesRequired << " different shades.\n" 152 << "Excluding pixels with no full coverage (pixels on the shared edge of the triangle pair)." 153 << tcu::TestLog::EndMessage; 154 155 for (int y = 0; y < RENDER_SIZE; ++y) 156 for (int x = 0; x < RENDER_SIZE; ++x) 157 { 158 const tcu::RGBA color = resultImage.getPixel(x, y); 159 const deUint32 packed = ((deUint32)color.getRed()) + ((deUint32)color.getGreen() << 8) + ((deUint32)color.getGreen() << 16); 160 161 // on the triangle edge, skip 162 if (x == y) 163 continue; 164 165 if (shadeFrequency.find(packed) == shadeFrequency.end()) 166 shadeFrequency[packed] = 1; 167 else 168 shadeFrequency[packed] = shadeFrequency[packed] + 1; 169 } 170 171 for (std::map<deUint32, int>::const_iterator it = shadeFrequency.begin(); it != shadeFrequency.end(); ++it) 172 if (it->second < rareThreshold) 173 rareCount++; 174 175 m_testCtx.getLog() 176 << tcu::TestLog::Message 177 << "Found " << (int)shadeFrequency.size() << " different shades.\n" 178 << "\tRare (less than " << rareThreshold << " pixels): " << rareCount << "\n" 179 << "\tCommon: " << (int)shadeFrequency.size() - rareCount << "\n" 180 << tcu::TestLog::EndMessage; 181 182 if ((int)shadeFrequency.size() < numShadesRequired) 183 { 184 m_testCtx.getLog() << tcu::TestLog::Message << "Image verification failed." << tcu::TestLog::EndMessage; 185 return false; 186 } 187 return true; 188 } 189 190 class SampleQualifierRenderCase : public MultisampleShadeCountRenderCase 191 { 192 public: 193 SampleQualifierRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target); 194 ~SampleQualifierRenderCase (void); 195 196 void init (void); 197 198 private: 199 std::string genVertexSource (int numTargetSamples) const; 200 std::string genFragmentSource (int numTargetSamples) const; 201 std::string getIterationDescription (int iteration) const; 202 }; 203 204 SampleQualifierRenderCase::SampleQualifierRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target) 205 : MultisampleShadeCountRenderCase(context, name, description, numSamples, target) 206 { 207 m_numIterations = 6; // float, vec2, .3, .4, array, struct 208 } 209 210 SampleQualifierRenderCase::~SampleQualifierRenderCase (void) 211 { 212 } 213 214 void SampleQualifierRenderCase::init (void) 215 { 216 const bool isSingleSampleTarget = (m_renderTarget != TARGET_DEFAULT && m_numRequestedSamples == 0) || (m_renderTarget == TARGET_DEFAULT && m_context.getRenderTarget().getNumSamples() <= 1); 217 218 // test purpose and expectations 219 if (isSingleSampleTarget) 220 { 221 m_testCtx.getLog() 222 << tcu::TestLog::Message 223 << "Verifying that a sample-qualified varying is given different values for different samples.\n" 224 << " Render high-frequency function, map result to black/white.\n" 225 << " => Resulting image image should contain both black and white pixels.\n" 226 << tcu::TestLog::EndMessage; 227 } 228 else 229 { 230 m_testCtx.getLog() 231 << tcu::TestLog::Message 232 << "Verifying that a sample-qualified varying is given different values for different samples.\n" 233 << " Render high-frequency function, map result to black/white.\n" 234 << " => Resulting image should contain n+1 shades of gray, n = sample count.\n" 235 << tcu::TestLog::EndMessage; 236 } 237 238 MultisampleShadeCountRenderCase::init(); 239 } 240 241 std::string SampleQualifierRenderCase::genVertexSource (int numTargetSamples) const 242 { 243 DE_UNREF(numTargetSamples); 244 245 std::ostringstream buf; 246 247 buf << "${GLSL_VERSION_DECL}\n" 248 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 249 "in highp vec4 a_position;\n"; 250 251 if (m_iteration == 0) 252 buf << "sample out highp float v_input;\n"; 253 else if (m_iteration == 1) 254 buf << "sample out highp vec2 v_input;\n"; 255 else if (m_iteration == 2) 256 buf << "sample out highp vec3 v_input;\n"; 257 else if (m_iteration == 3) 258 buf << "sample out highp vec4 v_input;\n"; 259 else if (m_iteration == 4) 260 buf << "sample out highp float[2] v_input;\n"; 261 else if (m_iteration == 5) 262 buf << "struct VaryingStruct { highp float a; highp float b; };\n" 263 "sample out VaryingStruct v_input;\n"; 264 else 265 DE_ASSERT(false); 266 267 buf << "void main (void)\n" 268 "{\n" 269 " gl_Position = a_position;\n"; 270 271 if (m_iteration == 0) 272 buf << " v_input = a_position.x + exp(a_position.y) + step(0.9, a_position.x)*step(a_position.y, -0.9)*8.0;\n"; 273 else if (m_iteration == 1) 274 buf << " v_input = a_position.xy;\n"; 275 else if (m_iteration == 2) 276 buf << " v_input = vec3(a_position.xy, a_position.x * 2.0 - a_position.y);\n"; 277 else if (m_iteration == 3) 278 buf << " v_input = vec4(a_position.xy, a_position.x * 2.0 - a_position.y, a_position.x*a_position.y);\n"; 279 else if (m_iteration == 4) 280 buf << " v_input[0] = a_position.x;\n" 281 " v_input[1] = a_position.y;\n"; 282 else if (m_iteration == 5) 283 buf << " v_input.a = a_position.x;\n" 284 " v_input.b = a_position.y;\n"; 285 else 286 DE_ASSERT(false); 287 288 buf << "}"; 289 290 return specializeShader(buf.str(), m_context.getRenderContext().getType());; 291 } 292 293 std::string SampleQualifierRenderCase::genFragmentSource (int numTargetSamples) const 294 { 295 DE_UNREF(numTargetSamples); 296 297 std::ostringstream buf; 298 299 buf << "${GLSL_VERSION_DECL}\n" 300 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}"; 301 302 if (m_iteration == 0) 303 buf << "sample in highp float v_input;\n"; 304 else if (m_iteration == 1) 305 buf << "sample in highp vec2 v_input;\n"; 306 else if (m_iteration == 2) 307 buf << "sample in highp vec3 v_input;\n"; 308 else if (m_iteration == 3) 309 buf << "sample in highp vec4 v_input;\n"; 310 else if (m_iteration == 4) 311 buf << "sample in highp float[2] v_input;\n"; 312 else if (m_iteration == 5) 313 buf << "struct VaryingStruct { highp float a; highp float b; };\n" 314 "sample in VaryingStruct v_input;\n"; 315 else 316 DE_ASSERT(false); 317 318 buf << "layout(location = 0) out mediump vec4 fragColor;\n" 319 "void main (void)\n" 320 "{\n"; 321 322 if (m_iteration == 0) 323 buf << " highp float field = exp(v_input) + v_input*v_input;\n"; 324 else if (m_iteration == 1) 325 buf << " highp float field = dot(v_input.xy, v_input.xy) + dot(21.0 * v_input.xx, sin(3.1 * v_input.xy));\n"; 326 else if (m_iteration == 2) 327 buf << " highp float field = dot(v_input.xy, v_input.xy) + dot(21.0 * v_input.zx, sin(3.1 * v_input.zy));\n"; 328 else if (m_iteration == 3) 329 buf << " highp float field = dot(v_input.xy, v_input.zw) + dot(21.0 * v_input.zy, sin(3.1 * v_input.zw));\n"; 330 else if (m_iteration == 4) 331 buf << " highp float field = dot(vec2(v_input[0], v_input[1]), vec2(v_input[0], v_input[1])) + dot(21.0 * vec2(v_input[0]), sin(3.1 * vec2(v_input[0], v_input[1])));\n"; 332 else if (m_iteration == 5) 333 buf << " highp float field = dot(vec2(v_input.a, v_input.b), vec2(v_input.a, v_input.b)) + dot(21.0 * vec2(v_input.a), sin(3.1 * vec2(v_input.a, v_input.b)));\n"; 334 else 335 DE_ASSERT(false); 336 337 buf << " fragColor = vec4(1.0, 1.0, 1.0, 1.0);\n" 338 "\n" 339 " if (fract(field) > 0.5)\n" 340 " fragColor = vec4(0.0, 0.0, 0.0, 1.0);\n" 341 "}"; 342 343 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 344 } 345 346 std::string SampleQualifierRenderCase::getIterationDescription (int iteration) const 347 { 348 if (iteration == 0) 349 return "Test with float varying"; 350 else if (iteration == 1) 351 return "Test with vec2 varying"; 352 else if (iteration == 2) 353 return "Test with vec3 varying"; 354 else if (iteration == 3) 355 return "Test with vec4 varying"; 356 else if (iteration == 4) 357 return "Test with array varying"; 358 else if (iteration == 5) 359 return "Test with struct varying"; 360 361 DE_ASSERT(false); 362 return ""; 363 } 364 365 class InterpolateAtSampleRenderCase : public MultisampleShadeCountRenderCase 366 { 367 public: 368 enum IndexingMode 369 { 370 INDEXING_STATIC, 371 INDEXING_DYNAMIC, 372 373 INDEXING_LAST 374 }; 375 InterpolateAtSampleRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, IndexingMode mode); 376 ~InterpolateAtSampleRenderCase (void); 377 378 void init (void); 379 void preDraw (void); 380 381 private: 382 std::string genVertexSource (int numTargetSamples) const; 383 std::string genFragmentSource (int numTargetSamples) const; 384 std::string getIterationDescription (int iteration) const; 385 386 const IndexingMode m_indexMode; 387 }; 388 389 InterpolateAtSampleRenderCase::InterpolateAtSampleRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, IndexingMode mode) 390 : MultisampleShadeCountRenderCase (context, name, description, numSamples, target) 391 , m_indexMode (mode) 392 { 393 DE_ASSERT(mode < INDEXING_LAST); 394 395 m_numIterations = 5; // float, vec2, .3, .4, array 396 } 397 398 InterpolateAtSampleRenderCase::~InterpolateAtSampleRenderCase (void) 399 { 400 } 401 402 void InterpolateAtSampleRenderCase::init (void) 403 { 404 const bool isSingleSampleTarget = (m_renderTarget != TARGET_DEFAULT && m_numRequestedSamples == 0) || (m_renderTarget == TARGET_DEFAULT && m_context.getRenderTarget().getNumSamples() <= 1); 405 406 // test purpose and expectations 407 if (isSingleSampleTarget) 408 { 409 m_testCtx.getLog() 410 << tcu::TestLog::Message 411 << "Verifying that a interpolateAtSample returns different values for different samples.\n" 412 << " Render high-frequency function, map result to black/white.\n" 413 << " => Resulting image image should contain both black and white pixels.\n" 414 << tcu::TestLog::EndMessage; 415 } 416 else 417 { 418 m_testCtx.getLog() 419 << tcu::TestLog::Message 420 << "Verifying that a interpolateAtSample returns different values for different samples.\n" 421 << " Render high-frequency function, map result to black/white.\n" 422 << " => Resulting image should contain n+1 shades of gray, n = sample count.\n" 423 << tcu::TestLog::EndMessage; 424 } 425 426 MultisampleShadeCountRenderCase::init(); 427 } 428 429 void InterpolateAtSampleRenderCase::preDraw (void) 430 { 431 if (m_indexMode == INDEXING_DYNAMIC) 432 { 433 const deInt32 range = m_numTargetSamples; 434 const deInt32 offset = 1; 435 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 436 const deInt32 offsetLoc = gl.getUniformLocation(m_program->getProgram(), "u_offset"); 437 const deInt32 rangeLoc = gl.getUniformLocation(m_program->getProgram(), "u_range"); 438 439 if (offsetLoc == -1) 440 throw tcu::TestError("Location of u_offset was -1"); 441 if (rangeLoc == -1) 442 throw tcu::TestError("Location of u_range was -1"); 443 444 gl.uniform1i(offsetLoc, 0); 445 gl.uniform1i(rangeLoc, m_numTargetSamples); 446 GLU_EXPECT_NO_ERROR(gl.getError(), "set uniforms"); 447 448 m_testCtx.getLog() 449 << tcu::TestLog::Message 450 << "Set u_offset = " << offset << "\n" 451 << "Set u_range = " << range 452 << tcu::TestLog::EndMessage; 453 } 454 } 455 456 std::string InterpolateAtSampleRenderCase::genVertexSource (int numTargetSamples) const 457 { 458 DE_UNREF(numTargetSamples); 459 460 std::ostringstream buf; 461 462 buf << "${GLSL_VERSION_DECL}\n" 463 "in highp vec4 a_position;\n"; 464 465 if (m_iteration == 0) 466 buf << "out highp float v_input;\n"; 467 else if (m_iteration == 1) 468 buf << "out highp vec2 v_input;\n"; 469 else if (m_iteration == 2) 470 buf << "out highp vec3 v_input;\n"; 471 else if (m_iteration == 3) 472 buf << "out highp vec4 v_input;\n"; 473 else if (m_iteration == 4) 474 buf << "out highp vec2[2] v_input;\n"; 475 else 476 DE_ASSERT(false); 477 478 buf << "void main (void)\n" 479 "{\n" 480 " gl_Position = a_position;\n"; 481 482 if (m_iteration == 0) 483 buf << " v_input = a_position.x + exp(a_position.y) + step(0.9, a_position.x)*step(a_position.y, -0.9)*8.0;\n"; 484 else if (m_iteration == 1) 485 buf << " v_input = a_position.xy;\n"; 486 else if (m_iteration == 2) 487 buf << " v_input = vec3(a_position.xy, a_position.x * 2.0 - a_position.y);\n"; 488 else if (m_iteration == 3) 489 buf << " v_input = vec4(a_position.xy, a_position.x * 2.0 - a_position.y, a_position.x*a_position.y);\n"; 490 else if (m_iteration == 4) 491 buf << " v_input[0] = a_position.yx + vec2(0.5, 0.5);\n" 492 " v_input[1] = a_position.xy;\n"; 493 else 494 DE_ASSERT(false); 495 496 buf << "}"; 497 498 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 499 } 500 501 std::string InterpolateAtSampleRenderCase::genFragmentSource (int numTargetSamples) const 502 { 503 std::ostringstream buf; 504 505 buf << "${GLSL_VERSION_DECL}\n" 506 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}"; 507 508 if (m_iteration == 0) 509 buf << "in highp float v_input;\n"; 510 else if (m_iteration == 1) 511 buf << "in highp vec2 v_input;\n"; 512 else if (m_iteration == 2) 513 buf << "in highp vec3 v_input;\n"; 514 else if (m_iteration == 3) 515 buf << "in highp vec4 v_input;\n"; 516 else if (m_iteration == 4) 517 buf << "in highp vec2[2] v_input;\n"; 518 else 519 DE_ASSERT(false); 520 521 buf << "layout(location = 0) out mediump vec4 fragColor;\n"; 522 523 if (m_indexMode == INDEXING_DYNAMIC) 524 buf << "uniform highp int u_offset;\n" 525 "uniform highp int u_range;\n"; 526 527 buf << "void main (void)\n" 528 "{\n" 529 " mediump int coverage = 0;\n" 530 "\n"; 531 532 if (m_indexMode == INDEXING_STATIC) 533 { 534 for (int ndx = 0; ndx < numTargetSamples; ++ndx) 535 { 536 if (m_iteration == 0) 537 buf << " highp float sampleInput" << ndx << " = interpolateAtSample(v_input, " << ndx << ");\n"; 538 else if (m_iteration == 1) 539 buf << " highp vec2 sampleInput" << ndx << " = interpolateAtSample(v_input, " << ndx << ");\n"; 540 else if (m_iteration == 2) 541 buf << " highp vec3 sampleInput" << ndx << " = interpolateAtSample(v_input, " << ndx << ");\n"; 542 else if (m_iteration == 3) 543 buf << " highp vec4 sampleInput" << ndx << " = interpolateAtSample(v_input, " << ndx << ");\n"; 544 else if (m_iteration == 4) 545 buf << " highp vec2 sampleInput" << ndx << " = interpolateAtSample(v_input[1], " << ndx << ");\n"; 546 else 547 DE_ASSERT(false); 548 } 549 buf << "\n"; 550 551 for (int ndx = 0; ndx < numTargetSamples; ++ndx) 552 { 553 if (m_iteration == 0) 554 buf << " highp float field" << ndx << " = exp(sampleInput" << ndx << ") + sampleInput" << ndx << "*sampleInput" << ndx << ";\n"; 555 else if (m_iteration == 1 || m_iteration == 4) 556 buf << " highp float field" << ndx << " = dot(sampleInput" << ndx << ", sampleInput" << ndx << ") + dot(21.0 * sampleInput" << ndx << ".xx, sin(3.1 * sampleInput" << ndx << "));\n"; 557 else if (m_iteration == 2) 558 buf << " highp float field" << ndx << " = dot(sampleInput" << ndx << ".xy, sampleInput" << ndx << ".xy) + dot(21.0 * sampleInput" << ndx << ".zx, sin(3.1 * sampleInput" << ndx << ".zy));\n"; 559 else if (m_iteration == 3) 560 buf << " highp float field" << ndx << " = dot(sampleInput" << ndx << ".xy, sampleInput" << ndx << ".zw) + dot(21.0 * sampleInput" << ndx << ".zy, sin(3.1 * sampleInput" << ndx << ".zw));\n"; 561 else 562 DE_ASSERT(false); 563 } 564 buf << "\n"; 565 566 for (int ndx = 0; ndx < numTargetSamples; ++ndx) 567 buf << " if (fract(field" << ndx << ") <= 0.5)\n" 568 " ++coverage;\n"; 569 } 570 else if (m_indexMode == INDEXING_DYNAMIC) 571 { 572 buf << " for (int ndx = 0; ndx < " << numTargetSamples << "; ++ndx)\n" 573 " {\n"; 574 575 if (m_iteration == 0) 576 buf << " highp float sampleInput = interpolateAtSample(v_input, (u_offset + ndx) % u_range);\n"; 577 else if (m_iteration == 1) 578 buf << " highp vec2 sampleInput = interpolateAtSample(v_input, (u_offset + ndx) % u_range);\n"; 579 else if (m_iteration == 2) 580 buf << " highp vec3 sampleInput = interpolateAtSample(v_input, (u_offset + ndx) % u_range);\n"; 581 else if (m_iteration == 3) 582 buf << " highp vec4 sampleInput = interpolateAtSample(v_input, (u_offset + ndx) % u_range);\n"; 583 else if (m_iteration == 4) 584 buf << " highp vec2 sampleInput = interpolateAtSample(v_input[1], (u_offset + ndx) % u_range);\n"; 585 else 586 DE_ASSERT(false); 587 588 if (m_iteration == 0) 589 buf << " highp float field = exp(sampleInput) + sampleInput*sampleInput;\n"; 590 else if (m_iteration == 1 || m_iteration == 4) 591 buf << " highp float field = dot(sampleInput, sampleInput) + dot(21.0 * sampleInput.xx, sin(3.1 * sampleInput));\n"; 592 else if (m_iteration == 2) 593 buf << " highp float field = dot(sampleInput.xy, sampleInput.xy) + dot(21.0 * sampleInput.zx, sin(3.1 * sampleInput.zy));\n"; 594 else if (m_iteration == 3) 595 buf << " highp float field = dot(sampleInput.xy, sampleInput.zw) + dot(21.0 * sampleInput.zy, sin(3.1 * sampleInput.zw));\n"; 596 else 597 DE_ASSERT(false); 598 599 buf << " if (fract(field) <= 0.5)\n" 600 " ++coverage;\n" 601 " }\n"; 602 } 603 604 buf << " fragColor = vec4(vec3(float(coverage) / float(" << numTargetSamples << ")), 1.0);\n" 605 "}"; 606 607 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 608 } 609 610 std::string InterpolateAtSampleRenderCase::getIterationDescription (int iteration) const 611 { 612 if (iteration == 0) 613 return "Test with float varying"; 614 else if (iteration < 4) 615 return "Test with vec" + de::toString(iteration+1) + " varying"; 616 else if (iteration == 4) 617 return "Test with array varying"; 618 619 DE_ASSERT(false); 620 return ""; 621 } 622 623 class SingleSampleInterpolateAtSampleCase : public MultisampleShaderRenderUtil::MultisampleRenderCase 624 { 625 public: 626 enum SampleCase 627 { 628 SAMPLE_0 = 0, 629 SAMPLE_N, 630 631 SAMPLE_LAST 632 }; 633 634 SingleSampleInterpolateAtSampleCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, SampleCase sampleCase); 635 virtual ~SingleSampleInterpolateAtSampleCase (void); 636 637 void init (void); 638 639 private: 640 enum 641 { 642 RENDER_SIZE = 32 643 }; 644 645 std::string genVertexSource (int numTargetSamples) const; 646 std::string genFragmentSource (int numTargetSamples) const; 647 bool verifyImage (const tcu::Surface& resultImage); 648 649 const SampleCase m_sampleCase; 650 }; 651 652 SingleSampleInterpolateAtSampleCase::SingleSampleInterpolateAtSampleCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, SampleCase sampleCase) 653 : MultisampleShaderRenderUtil::MultisampleRenderCase (context, name, description, numSamples, target, RENDER_SIZE) 654 , m_sampleCase (sampleCase) 655 { 656 DE_ASSERT(numSamples == 0); 657 DE_ASSERT(sampleCase < SAMPLE_LAST); 658 } 659 660 SingleSampleInterpolateAtSampleCase::~SingleSampleInterpolateAtSampleCase (void) 661 { 662 } 663 664 void SingleSampleInterpolateAtSampleCase::init (void) 665 { 666 // requirements 667 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 668 TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation extension"); 669 if (m_renderTarget == TARGET_DEFAULT && m_context.getRenderTarget().getNumSamples() > 1) 670 TCU_THROW(NotSupportedError, "Non-multisample framebuffer required"); 671 672 // test purpose and expectations 673 m_testCtx.getLog() 674 << tcu::TestLog::Message 675 << "Verifying that using interpolateAtSample with multisample buffers not available returns sample evaluated at the center of the pixel.\n" 676 << " Interpolate varying containing screen space location.\n" 677 << " => fract(screen space location) should be (about) (0.5, 0.5)\n" 678 << tcu::TestLog::EndMessage; 679 680 MultisampleShaderRenderUtil::MultisampleRenderCase::init(); 681 } 682 683 std::string SingleSampleInterpolateAtSampleCase::genVertexSource (int numTargetSamples) const 684 { 685 DE_UNREF(numTargetSamples); 686 687 std::ostringstream buf; 688 689 buf << "${GLSL_VERSION_DECL}\n" 690 "in highp vec4 a_position;\n" 691 "out highp vec2 v_position;\n" 692 "void main (void)\n" 693 "{\n" 694 " gl_Position = a_position;\n" 695 " v_position = (a_position.xy + vec2(1.0, 1.0)) / 2.0 * vec2(" << (int)RENDER_SIZE << ".0, " << (int)RENDER_SIZE << ".0);\n" 696 "}\n"; 697 698 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 699 } 700 701 std::string SingleSampleInterpolateAtSampleCase::genFragmentSource (int numTargetSamples) const 702 { 703 DE_UNREF(numTargetSamples); 704 705 std::ostringstream buf; 706 707 buf << "${GLSL_VERSION_DECL}\n" 708 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 709 "in highp vec2 v_position;\n" 710 "layout(location = 0) out mediump vec4 fragColor;\n" 711 "void main (void)\n" 712 "{\n" 713 " const highp float threshold = 0.15625; // 4 subpixel bits. Assume 3 accurate bits + 0.03125 for other errors\n"; // 0.03125 = mediump epsilon when value = 32 (RENDER_SIZE) 714 715 if (m_sampleCase == SAMPLE_0) 716 { 717 buf << " highp vec2 samplePosition = interpolateAtSample(v_position, 0);\n" 718 " highp vec2 positionInsideAPixel = fract(samplePosition);\n" 719 "\n" 720 " if (abs(positionInsideAPixel.x - 0.5) <= threshold && abs(positionInsideAPixel.y - 0.5) <= threshold)\n" 721 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 722 " else\n" 723 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 724 "}\n"; 725 } 726 else if (m_sampleCase == SAMPLE_N) 727 { 728 buf << " bool allOk = true;\n" 729 " for (int sampleNdx = 159; sampleNdx < 163; ++sampleNdx)\n" 730 " {\n" 731 " highp vec2 samplePosition = interpolateAtSample(v_position, sampleNdx);\n" 732 " highp vec2 positionInsideAPixel = fract(samplePosition);\n" 733 " if (abs(positionInsideAPixel.x - 0.5) > threshold || abs(positionInsideAPixel.y - 0.5) > threshold)\n" 734 " allOk = false;\n" 735 " }\n" 736 "\n" 737 " if (allOk)\n" 738 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 739 " else\n" 740 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 741 "}\n"; 742 } 743 else 744 DE_ASSERT(false); 745 746 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 747 } 748 749 bool SingleSampleInterpolateAtSampleCase::verifyImage (const tcu::Surface& resultImage) 750 { 751 return verifyGreenImage(resultImage, m_testCtx.getLog()); 752 } 753 754 class CentroidRenderCase : public MultisampleShaderRenderUtil::MultisampleRenderCase 755 { 756 public: 757 CentroidRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, int renderSize); 758 virtual ~CentroidRenderCase (void); 759 760 void init (void); 761 762 private: 763 void setupRenderData (void); 764 }; 765 766 CentroidRenderCase::CentroidRenderCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, int renderSize) 767 : MultisampleShaderRenderUtil::MultisampleRenderCase(context, name, description, numSamples, target, renderSize) 768 { 769 } 770 771 CentroidRenderCase::~CentroidRenderCase (void) 772 { 773 } 774 775 void CentroidRenderCase::init (void) 776 { 777 // requirements 778 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 779 TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation extension"); 780 781 MultisampleShaderRenderUtil::MultisampleRenderCase::init(); 782 } 783 784 void CentroidRenderCase::setupRenderData (void) 785 { 786 const int numTriangles = 200; 787 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 788 std::vector<tcu::Vec4> data (numTriangles * 3 * 3); 789 790 m_renderMode = GL_TRIANGLES; 791 m_renderCount = numTriangles * 3; 792 m_renderSceneDescription = "triangle fan of narrow triangles"; 793 794 m_renderAttribs["a_position"].offset = 0; 795 m_renderAttribs["a_position"].stride = (int)sizeof(float[4]) * 3; 796 m_renderAttribs["a_barycentricsA"].offset = (int)sizeof(float[4]); 797 m_renderAttribs["a_barycentricsA"].stride = (int)sizeof(float[4]) * 3; 798 m_renderAttribs["a_barycentricsB"].offset = (int)sizeof(float[4]) * 2; 799 m_renderAttribs["a_barycentricsB"].stride = (int)sizeof(float[4]) * 3; 800 801 for (int triangleNdx = 0; triangleNdx < numTriangles; ++triangleNdx) 802 { 803 const float angle = ((float)triangleNdx) / (float)numTriangles * 2.0f * DE_PI; 804 const float nextAngle = ((float)triangleNdx + 1.0f) / (float)numTriangles * 2.0f * DE_PI; 805 806 data[(triangleNdx * 3 + 0) * 3 + 0] = tcu::Vec4(0.2f, -0.3f, 0.0f, 1.0f); 807 data[(triangleNdx * 3 + 0) * 3 + 1] = tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f); 808 data[(triangleNdx * 3 + 0) * 3 + 2] = tcu::Vec4(1.0f, 0.0f, 0.0f, 0.0f); 809 810 data[(triangleNdx * 3 + 1) * 3 + 0] = tcu::Vec4(2.0f * deFloatCos(angle), 2.0f * deFloatSin(angle), 0.0f, 1.0f); 811 data[(triangleNdx * 3 + 1) * 3 + 1] = tcu::Vec4(0.0f, 1.0f, 0.0f, 0.0f); 812 data[(triangleNdx * 3 + 1) * 3 + 2] = tcu::Vec4(0.0f, 1.0f, 0.0f, 0.0f); 813 814 data[(triangleNdx * 3 + 2) * 3 + 0] = tcu::Vec4(2.0f * deFloatCos(nextAngle), 2.0f * deFloatSin(nextAngle), 0.0f, 1.0f); 815 data[(triangleNdx * 3 + 2) * 3 + 1] = tcu::Vec4(0.0f, 0.0f, 1.0f, 0.0f); 816 data[(triangleNdx * 3 + 2) * 3 + 2] = tcu::Vec4(0.0f, 0.0f, 1.0f, 0.0f); 817 } 818 819 gl.bindBuffer(GL_ARRAY_BUFFER, m_buffer); 820 gl.bufferData(GL_ARRAY_BUFFER, (glw::GLsizeiptr)(data.size() * sizeof(tcu::Vec4)), data[0].getPtr(), GL_STATIC_DRAW); 821 } 822 823 class CentroidQualifierAtSampleCase : public CentroidRenderCase 824 { 825 public: 826 CentroidQualifierAtSampleCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target); 827 virtual ~CentroidQualifierAtSampleCase (void); 828 829 void init (void); 830 831 private: 832 enum 833 { 834 RENDER_SIZE = 128 835 }; 836 837 std::string genVertexSource (int numTargetSamples) const; 838 std::string genFragmentSource (int numTargetSamples) const; 839 bool verifyImage (const tcu::Surface& resultImage); 840 }; 841 842 CentroidQualifierAtSampleCase::CentroidQualifierAtSampleCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target) 843 : CentroidRenderCase(context, name, description, numSamples, target, RENDER_SIZE) 844 { 845 } 846 847 CentroidQualifierAtSampleCase::~CentroidQualifierAtSampleCase (void) 848 { 849 } 850 851 void CentroidQualifierAtSampleCase::init (void) 852 { 853 // test purpose and expectations 854 m_testCtx.getLog() 855 << tcu::TestLog::Message 856 << "Verifying that interpolateAtSample ignores the centroid-qualifier.\n" 857 << " Draw a fan of narrow triangles (large number of pixels on the edges).\n" 858 << " Set varyings 'barycentricsA' and 'barycentricsB' to contain barycentric coordinates.\n" 859 << " Add centroid-qualifier for barycentricsB.\n" 860 << " => interpolateAtSample(barycentricsB, N) ~= interpolateAtSample(barycentricsA, N)\n" 861 << tcu::TestLog::EndMessage; 862 863 CentroidRenderCase::init(); 864 } 865 866 std::string CentroidQualifierAtSampleCase::genVertexSource (int numTargetSamples) const 867 { 868 DE_UNREF(numTargetSamples); 869 870 std::ostringstream buf; 871 872 buf << "${GLSL_VERSION_DECL}\n" 873 "in highp vec4 a_position;\n" 874 "in highp vec4 a_barycentricsA;\n" 875 "in highp vec4 a_barycentricsB;\n" 876 "out highp vec3 v_barycentricsA;\n" 877 "centroid out highp vec3 v_barycentricsB;\n" 878 "void main (void)\n" 879 "{\n" 880 " gl_Position = a_position;\n" 881 " v_barycentricsA = a_barycentricsA.xyz;\n" 882 " v_barycentricsB = a_barycentricsB.xyz;\n" 883 "}\n"; 884 885 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 886 } 887 888 std::string CentroidQualifierAtSampleCase::genFragmentSource (int numTargetSamples) const 889 { 890 DE_UNREF(numTargetSamples); 891 892 std::ostringstream buf; 893 894 buf << "${GLSL_VERSION_DECL}\n" 895 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 896 "in highp vec3 v_barycentricsA;\n" 897 "centroid in highp vec3 v_barycentricsB;\n" 898 "layout(location = 0) out mediump vec4 fragColor;\n" 899 "void main (void)\n" 900 "{\n" 901 " const highp float threshold = 0.0005;\n" 902 " bool allOk = true;\n" 903 "\n" 904 " for (int sampleNdx = 0; sampleNdx < " << numTargetSamples << "; ++sampleNdx)\n" 905 " {\n" 906 " highp vec3 sampleA = interpolateAtSample(v_barycentricsA, sampleNdx);\n" 907 " highp vec3 sampleB = interpolateAtSample(v_barycentricsB, sampleNdx);\n" 908 " bool valuesEqual = all(lessThan(abs(sampleA - sampleB), vec3(threshold)));\n" 909 " if (!valuesEqual)\n" 910 " allOk = false;\n" 911 " }\n" 912 "\n" 913 " if (allOk)\n" 914 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 915 " else\n" 916 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 917 "}\n"; 918 919 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 920 } 921 922 bool CentroidQualifierAtSampleCase::verifyImage (const tcu::Surface& resultImage) 923 { 924 return verifyGreenImage(resultImage, m_testCtx.getLog()); 925 } 926 927 class InterpolateAtSampleIDCase : public MultisampleShaderRenderUtil::MultisampleRenderCase 928 { 929 public: 930 InterpolateAtSampleIDCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target); 931 virtual ~InterpolateAtSampleIDCase (void); 932 933 void init (void); 934 private: 935 enum 936 { 937 RENDER_SIZE = 32 938 }; 939 940 std::string genVertexSource (int numTargetSamples) const; 941 std::string genFragmentSource (int numTargetSamples) const; 942 bool verifyImage (const tcu::Surface& resultImage); 943 }; 944 945 InterpolateAtSampleIDCase::InterpolateAtSampleIDCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target) 946 : MultisampleShaderRenderUtil::MultisampleRenderCase(context, name, description, numSamples, target, RENDER_SIZE) 947 { 948 } 949 950 InterpolateAtSampleIDCase::~InterpolateAtSampleIDCase (void) 951 { 952 } 953 954 void InterpolateAtSampleIDCase::init (void) 955 { 956 // requirements 957 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 958 TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation extension"); 959 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_sample_variables") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 960 TCU_THROW(NotSupportedError, "Test requires GL_OES_sample_variables extension"); 961 962 // test purpose and expectations 963 m_testCtx.getLog() 964 << tcu::TestLog::Message 965 << "Verifying that interpolateAtSample with the sample set to the current sampleID returns consistent values.\n" 966 << " Interpolate varying containing screen space location.\n" 967 << " => interpolateAtSample(varying, sampleID) = varying" 968 << tcu::TestLog::EndMessage; 969 970 MultisampleShaderRenderUtil::MultisampleRenderCase::init(); 971 } 972 973 std::string InterpolateAtSampleIDCase::genVertexSource (int numTargetSamples) const 974 { 975 DE_UNREF(numTargetSamples); 976 977 std::ostringstream buf; 978 979 buf << "${GLSL_VERSION_DECL}\n" 980 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 981 "in highp vec4 a_position;\n" 982 "sample out highp vec2 v_screenPosition;\n" 983 "void main (void)\n" 984 "{\n" 985 " gl_Position = a_position;\n" 986 " v_screenPosition = (a_position.xy + vec2(1.0, 1.0)) / 2.0 * vec2(" << (int)RENDER_SIZE << ".0, " << (int)RENDER_SIZE << ".0);\n" 987 "}\n"; 988 989 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 990 } 991 992 std::string InterpolateAtSampleIDCase::genFragmentSource (int numTargetSamples) const 993 { 994 DE_UNREF(numTargetSamples); 995 996 std::ostringstream buf; 997 998 buf << "${GLSL_VERSION_DECL}\n" 999 "${GLSL_EXT_SAMPLE_VARIABLES}" 1000 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 1001 "sample in highp vec2 v_screenPosition;\n" 1002 "layout(location = 0) out mediump vec4 fragColor;\n" 1003 "void main (void)\n" 1004 "{\n" 1005 " const highp float threshold = 0.15625; // 4 subpixel bits. Assume 3 accurate bits + 0.03125 for other errors\n" // 0.03125 = mediump epsilon when value = 32 (RENDER_SIZE) 1006 "\n" 1007 " highp vec2 offsetValue = interpolateAtSample(v_screenPosition, gl_SampleID);\n" 1008 " highp vec2 refValue = v_screenPosition;\n" 1009 "\n" 1010 " bool valuesEqual = all(lessThan(abs(offsetValue - refValue), vec2(threshold)));\n" 1011 " if (valuesEqual)\n" 1012 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 1013 " else\n" 1014 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 1015 "}\n"; 1016 1017 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1018 } 1019 1020 bool InterpolateAtSampleIDCase::verifyImage (const tcu::Surface& resultImage) 1021 { 1022 return verifyGreenImage(resultImage, m_testCtx.getLog()); 1023 } 1024 1025 class InterpolateAtCentroidCase : public CentroidRenderCase 1026 { 1027 public: 1028 enum TestType 1029 { 1030 TEST_CONSISTENCY = 0, 1031 TEST_ARRAY_ELEMENT, 1032 1033 TEST_LAST 1034 }; 1035 1036 InterpolateAtCentroidCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, TestType type); 1037 virtual ~InterpolateAtCentroidCase (void); 1038 1039 void init (void); 1040 1041 private: 1042 enum 1043 { 1044 RENDER_SIZE = 128 1045 }; 1046 1047 std::string genVertexSource (int numTargetSamples) const; 1048 std::string genFragmentSource (int numTargetSamples) const; 1049 bool verifyImage (const tcu::Surface& resultImage); 1050 1051 const TestType m_type; 1052 }; 1053 1054 InterpolateAtCentroidCase::InterpolateAtCentroidCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, TestType type) 1055 : CentroidRenderCase (context, name, description, numSamples, target, RENDER_SIZE) 1056 , m_type (type) 1057 { 1058 } 1059 1060 InterpolateAtCentroidCase::~InterpolateAtCentroidCase (void) 1061 { 1062 } 1063 1064 void InterpolateAtCentroidCase::init (void) 1065 { 1066 // test purpose and expectations 1067 if (m_type == TEST_CONSISTENCY) 1068 { 1069 m_testCtx.getLog() 1070 << tcu::TestLog::Message 1071 << "Verifying that interpolateAtCentroid does not return different values than a corresponding centroid-qualified varying.\n" 1072 << " Draw a fan of narrow triangles (large number of pixels on the edges).\n" 1073 << " Set varyings 'barycentricsA' and 'barycentricsB' to contain barycentric coordinates.\n" 1074 << " Add centroid-qualifier for barycentricsB.\n" 1075 << " => interpolateAtCentroid(barycentricsA) ~= barycentricsB\n" 1076 << tcu::TestLog::EndMessage; 1077 } 1078 else if (m_type == TEST_ARRAY_ELEMENT) 1079 { 1080 m_testCtx.getLog() 1081 << tcu::TestLog::Message 1082 << "Testing interpolateAtCentroid with element of array as an argument." 1083 << tcu::TestLog::EndMessage; 1084 } 1085 else 1086 DE_ASSERT(false); 1087 1088 CentroidRenderCase::init(); 1089 } 1090 1091 std::string InterpolateAtCentroidCase::genVertexSource (int numTargetSamples) const 1092 { 1093 DE_UNREF(numTargetSamples); 1094 1095 std::ostringstream buf; 1096 1097 if (m_type == TEST_CONSISTENCY) 1098 buf << "${GLSL_VERSION_DECL}\n" 1099 "in highp vec4 a_position;\n" 1100 "in highp vec4 a_barycentricsA;\n" 1101 "in highp vec4 a_barycentricsB;\n" 1102 "out highp vec3 v_barycentricsA;\n" 1103 "centroid out highp vec3 v_barycentricsB;\n" 1104 "void main (void)\n" 1105 "{\n" 1106 " gl_Position = a_position;\n" 1107 " v_barycentricsA = a_barycentricsA.xyz;\n" 1108 " v_barycentricsB = a_barycentricsB.xyz;\n" 1109 "}\n"; 1110 else if (m_type == TEST_ARRAY_ELEMENT) 1111 buf << "${GLSL_VERSION_DECL}\n" 1112 "in highp vec4 a_position;\n" 1113 "in highp vec4 a_barycentricsA;\n" 1114 "in highp vec4 a_barycentricsB;\n" 1115 "out highp vec3[2] v_barycentrics;\n" 1116 "void main (void)\n" 1117 "{\n" 1118 " gl_Position = a_position;\n" 1119 " v_barycentrics[0] = a_barycentricsA.xyz;\n" 1120 " v_barycentrics[1] = a_barycentricsB.xyz;\n" 1121 "}\n"; 1122 else 1123 DE_ASSERT(false); 1124 1125 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1126 } 1127 1128 std::string InterpolateAtCentroidCase::genFragmentSource (int numTargetSamples) const 1129 { 1130 DE_UNREF(numTargetSamples); 1131 1132 std::ostringstream buf; 1133 1134 if (m_type == TEST_CONSISTENCY) 1135 buf << "${GLSL_VERSION_DECL}\n" 1136 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 1137 "in highp vec3 v_barycentricsA;\n" 1138 "centroid in highp vec3 v_barycentricsB;\n" 1139 "layout(location = 0) out highp vec4 fragColor;\n" 1140 "void main (void)\n" 1141 "{\n" 1142 " const highp float threshold = 0.0005;\n" 1143 "\n" 1144 " highp vec3 centroidASampled = interpolateAtCentroid(v_barycentricsA);\n" 1145 " bool valuesEqual = all(lessThan(abs(centroidASampled - v_barycentricsB), vec3(threshold)));\n" 1146 " bool centroidAIsInvalid = any(greaterThan(centroidASampled, vec3(1.0))) ||\n" 1147 " any(lessThan(centroidASampled, vec3(0.0)));\n" 1148 " bool centroidBIsInvalid = any(greaterThan(v_barycentricsB, vec3(1.0))) ||\n" 1149 " any(lessThan(v_barycentricsB, vec3(0.0)));\n" 1150 "\n" 1151 " if (valuesEqual && !centroidAIsInvalid && !centroidBIsInvalid)\n" 1152 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 1153 " else if (centroidAIsInvalid || centroidBIsInvalid)\n" 1154 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 1155 " else\n" 1156 " fragColor = vec4(1.0, 1.0, 0.0, 1.0);\n" 1157 "}\n"; 1158 else if (m_type == TEST_ARRAY_ELEMENT) 1159 buf << "${GLSL_VERSION_DECL}\n" 1160 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 1161 "in highp vec3[2] v_barycentrics;\n" 1162 "layout(location = 0) out mediump vec4 fragColor;\n" 1163 "void main (void)\n" 1164 "{\n" 1165 " const highp float threshold = 0.0005;\n" 1166 "\n" 1167 " highp vec3 centroidInterpolated = interpolateAtCentroid(v_barycentrics[1]);\n" 1168 " bool centroidIsInvalid = any(greaterThan(centroidInterpolated, vec3(1.0))) ||\n" 1169 " any(lessThan(centroidInterpolated, vec3(0.0)));\n" 1170 "\n" 1171 " if (!centroidIsInvalid)\n" 1172 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 1173 " else\n" 1174 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 1175 "}\n"; 1176 else 1177 DE_ASSERT(false); 1178 1179 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1180 } 1181 1182 bool InterpolateAtCentroidCase::verifyImage (const tcu::Surface& resultImage) 1183 { 1184 return verifyGreenImage(resultImage, m_testCtx.getLog()); 1185 } 1186 1187 class InterpolateAtOffsetCase : public MultisampleShaderRenderUtil::MultisampleRenderCase 1188 { 1189 public: 1190 enum TestType 1191 { 1192 TEST_QUALIFIER_NONE = 0, 1193 TEST_QUALIFIER_CENTROID, 1194 TEST_QUALIFIER_SAMPLE, 1195 TEST_ARRAY_ELEMENT, 1196 1197 TEST_LAST 1198 }; 1199 InterpolateAtOffsetCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, TestType testType); 1200 virtual ~InterpolateAtOffsetCase (void); 1201 1202 void init (void); 1203 private: 1204 enum 1205 { 1206 RENDER_SIZE = 32 1207 }; 1208 1209 std::string genVertexSource (int numTargetSamples) const; 1210 std::string genFragmentSource (int numTargetSamples) const; 1211 bool verifyImage (const tcu::Surface& resultImage); 1212 1213 const TestType m_testType; 1214 }; 1215 1216 InterpolateAtOffsetCase::InterpolateAtOffsetCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target, TestType testType) 1217 : MultisampleShaderRenderUtil::MultisampleRenderCase (context, name, description, numSamples, target, RENDER_SIZE) 1218 , m_testType (testType) 1219 { 1220 DE_ASSERT(testType < TEST_LAST); 1221 } 1222 1223 InterpolateAtOffsetCase::~InterpolateAtOffsetCase (void) 1224 { 1225 } 1226 1227 void InterpolateAtOffsetCase::init (void) 1228 { 1229 // requirements 1230 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1231 TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation extension"); 1232 1233 // test purpose and expectations 1234 m_testCtx.getLog() 1235 << tcu::TestLog::Message 1236 << "Verifying that interpolateAtOffset returns correct values.\n" 1237 << " Interpolate varying containing screen space location.\n" 1238 << " => interpolateAtOffset(varying, offset) should be \"varying value at the pixel center\" + offset" 1239 << tcu::TestLog::EndMessage; 1240 1241 MultisampleShaderRenderUtil::MultisampleRenderCase::init(); 1242 } 1243 1244 std::string InterpolateAtOffsetCase::genVertexSource (int numTargetSamples) const 1245 { 1246 DE_UNREF(numTargetSamples); 1247 1248 std::ostringstream buf; 1249 buf << "${GLSL_VERSION_DECL}\n" 1250 << "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 1251 << "in highp vec4 a_position;\n"; 1252 1253 if (m_testType == TEST_QUALIFIER_NONE || m_testType == TEST_QUALIFIER_CENTROID || m_testType == TEST_QUALIFIER_SAMPLE) 1254 { 1255 const char* const qualifier = (m_testType == TEST_QUALIFIER_CENTROID) ? ("centroid ") : (m_testType == TEST_QUALIFIER_SAMPLE) ? ("sample ") : (""); 1256 buf << qualifier << "out highp vec2 v_screenPosition;\n" 1257 << qualifier << "out highp vec2 v_offset;\n"; 1258 } 1259 else if (m_testType == TEST_ARRAY_ELEMENT) 1260 { 1261 buf << "out highp vec2[2] v_screenPosition;\n" 1262 << "out highp vec2 v_offset;\n"; 1263 } 1264 else 1265 DE_ASSERT(false); 1266 1267 buf << "void main (void)\n" 1268 << "{\n" 1269 << " gl_Position = a_position;\n"; 1270 1271 if (m_testType != TEST_ARRAY_ELEMENT) 1272 buf << " v_screenPosition = (a_position.xy + vec2(1.0, 1.0)) / 2.0 * vec2(" << (int)RENDER_SIZE << ".0, " << (int)RENDER_SIZE << ".0);\n"; 1273 else 1274 buf << " v_screenPosition[0] = a_position.xy; // not used\n" 1275 " v_screenPosition[1] = (a_position.xy + vec2(1.0, 1.0)) / 2.0 * vec2(" << (int)RENDER_SIZE << ".0, " << (int)RENDER_SIZE << ".0);\n"; 1276 1277 buf << " v_offset = a_position.xy * 0.5f;\n" 1278 << "}\n"; 1279 1280 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1281 } 1282 1283 std::string InterpolateAtOffsetCase::genFragmentSource (int numTargetSamples) const 1284 { 1285 DE_UNREF(numTargetSamples); 1286 1287 const char* const arrayIndexing = (m_testType == TEST_ARRAY_ELEMENT) ? ("[1]") : (""); 1288 std::ostringstream buf; 1289 1290 buf << "${GLSL_VERSION_DECL}\n" 1291 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}"; 1292 1293 if (m_testType == TEST_QUALIFIER_NONE || m_testType == TEST_QUALIFIER_CENTROID || m_testType == TEST_QUALIFIER_SAMPLE) 1294 { 1295 const char* const qualifier = (m_testType == TEST_QUALIFIER_CENTROID) ? ("centroid ") : (m_testType == TEST_QUALIFIER_SAMPLE) ? ("sample ") : (""); 1296 buf << qualifier << "in highp vec2 v_screenPosition;\n" 1297 << qualifier << "in highp vec2 v_offset;\n"; 1298 } 1299 else if (m_testType == TEST_ARRAY_ELEMENT) 1300 { 1301 buf << "in highp vec2[2] v_screenPosition;\n" 1302 << "in highp vec2 v_offset;\n"; 1303 } 1304 else 1305 DE_ASSERT(false); 1306 1307 buf << "layout(location = 0) out mediump vec4 fragColor;\n" 1308 "void main (void)\n" 1309 "{\n" 1310 " const highp float threshold = 0.15625; // 4 subpixel bits. Assume 3 accurate bits + 0.03125 for other errors\n" // 0.03125 = mediump epsilon when value = 32 (RENDER_SIZE) 1311 "\n" 1312 " highp vec2 pixelCenter = floor(v_screenPosition" << arrayIndexing << ") + vec2(0.5, 0.5);\n" 1313 " highp vec2 offsetValue = interpolateAtOffset(v_screenPosition" << arrayIndexing << ", v_offset);\n" 1314 " highp vec2 refValue = pixelCenter + v_offset;\n" 1315 "\n" 1316 " bool valuesEqual = all(lessThan(abs(offsetValue - refValue), vec2(threshold)));\n" 1317 " if (valuesEqual)\n" 1318 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 1319 " else\n" 1320 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 1321 "}\n"; 1322 1323 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1324 } 1325 1326 bool InterpolateAtOffsetCase::verifyImage (const tcu::Surface& resultImage) 1327 { 1328 return verifyGreenImage(resultImage, m_testCtx.getLog()); 1329 } 1330 1331 class InterpolateAtSamplePositionCase : public MultisampleShaderRenderUtil::MultisampleRenderCase 1332 { 1333 public: 1334 InterpolateAtSamplePositionCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target); 1335 virtual ~InterpolateAtSamplePositionCase (void); 1336 1337 void init (void); 1338 private: 1339 enum 1340 { 1341 RENDER_SIZE = 32 1342 }; 1343 1344 std::string genVertexSource (int numTargetSamples) const; 1345 std::string genFragmentSource (int numTargetSamples) const; 1346 bool verifyImage (const tcu::Surface& resultImage); 1347 }; 1348 1349 InterpolateAtSamplePositionCase::InterpolateAtSamplePositionCase (Context& context, const char* name, const char* description, int numSamples, RenderTarget target) 1350 : MultisampleShaderRenderUtil::MultisampleRenderCase(context, name, description, numSamples, target, RENDER_SIZE) 1351 { 1352 } 1353 1354 InterpolateAtSamplePositionCase::~InterpolateAtSamplePositionCase (void) 1355 { 1356 } 1357 1358 void InterpolateAtSamplePositionCase::init (void) 1359 { 1360 // requirements 1361 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1362 TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation extension"); 1363 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_sample_variables") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1364 TCU_THROW(NotSupportedError, "Test requires GL_OES_sample_variables extension"); 1365 1366 // test purpose and expectations 1367 m_testCtx.getLog() 1368 << tcu::TestLog::Message 1369 << "Verifying that interpolateAtOffset with the offset of current sample position returns consistent values.\n" 1370 << " Interpolate varying containing screen space location.\n" 1371 << " => interpolateAtOffset(varying, currentOffset) = varying" 1372 << tcu::TestLog::EndMessage; 1373 1374 MultisampleShaderRenderUtil::MultisampleRenderCase::init(); 1375 } 1376 1377 std::string InterpolateAtSamplePositionCase::genVertexSource (int numTargetSamples) const 1378 { 1379 DE_UNREF(numTargetSamples); 1380 1381 std::ostringstream buf; 1382 1383 buf << "${GLSL_VERSION_DECL}\n" 1384 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 1385 "in highp vec4 a_position;\n" 1386 "sample out highp vec2 v_screenPosition;\n" 1387 "void main (void)\n" 1388 "{\n" 1389 " gl_Position = a_position;\n" 1390 " v_screenPosition = (a_position.xy + vec2(1.0, 1.0)) / 2.0 * vec2(" << (int)RENDER_SIZE << ".0, " << (int)RENDER_SIZE << ".0);\n" 1391 "}\n"; 1392 1393 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1394 } 1395 1396 std::string InterpolateAtSamplePositionCase::genFragmentSource (int numTargetSamples) const 1397 { 1398 DE_UNREF(numTargetSamples); 1399 1400 std::ostringstream buf; 1401 1402 buf << "${GLSL_VERSION_DECL}\n" 1403 "${GLSL_EXT_SAMPLE_VARIABLES}" 1404 "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 1405 "sample in highp vec2 v_screenPosition;\n" 1406 "layout(location = 0) out mediump vec4 fragColor;\n" 1407 "void main (void)\n" 1408 "{\n" 1409 " const highp float threshold = 0.15625; // 4 subpixel bits. Assume 3 accurate bits + 0.03125 for other errors\n" // 0.03125 = mediump epsilon when value = 32 (RENDER_SIZE) 1410 "\n" 1411 " highp vec2 offset = gl_SamplePosition - vec2(0.5, 0.5);\n" 1412 " highp vec2 offsetValue = interpolateAtOffset(v_screenPosition, offset);\n" 1413 " highp vec2 refValue = v_screenPosition;\n" 1414 "\n" 1415 " bool valuesEqual = all(lessThan(abs(offsetValue - refValue), vec2(threshold)));\n" 1416 " if (valuesEqual)\n" 1417 " fragColor = vec4(0.0, 1.0, 0.0, 1.0);\n" 1418 " else\n" 1419 " fragColor = vec4(1.0, 0.0, 0.0, 1.0);\n" 1420 "}\n"; 1421 1422 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1423 } 1424 1425 bool InterpolateAtSamplePositionCase::verifyImage (const tcu::Surface& resultImage) 1426 { 1427 return verifyGreenImage(resultImage, m_testCtx.getLog()); 1428 } 1429 1430 class NegativeCompileInterpolationCase : public TestCase 1431 { 1432 public: 1433 enum CaseType 1434 { 1435 CASE_VEC4_IDENTITY_SWIZZLE = 0, 1436 CASE_VEC4_CROP_SWIZZLE, 1437 CASE_VEC4_MIXED_SWIZZLE, 1438 CASE_INTERPOLATE_IVEC4, 1439 CASE_INTERPOLATE_UVEC4, 1440 CASE_INTERPOLATE_ARRAY, 1441 CASE_INTERPOLATE_STRUCT, 1442 CASE_INTERPOLATE_STRUCT_MEMBER, 1443 CASE_INTERPOLATE_LOCAL, 1444 CASE_INTERPOLATE_GLOBAL, 1445 CASE_INTERPOLATE_CONSTANT, 1446 1447 CASE_LAST 1448 }; 1449 enum InterpolatorType 1450 { 1451 INTERPOLATE_AT_SAMPLE = 0, 1452 INTERPOLATE_AT_CENTROID, 1453 INTERPOLATE_AT_OFFSET, 1454 1455 INTERPOLATE_LAST 1456 }; 1457 1458 NegativeCompileInterpolationCase (Context& context, const char* name, const char* description, CaseType caseType, InterpolatorType interpolator); 1459 1460 private: 1461 void init (void); 1462 IterateResult iterate (void); 1463 1464 std::string genShaderSource (void) const; 1465 1466 const CaseType m_caseType; 1467 const InterpolatorType m_interpolation; 1468 }; 1469 1470 NegativeCompileInterpolationCase::NegativeCompileInterpolationCase (Context& context, const char* name, const char* description, CaseType caseType, InterpolatorType interpolator) 1471 : TestCase (context, name, description) 1472 , m_caseType (caseType) 1473 , m_interpolation (interpolator) 1474 { 1475 DE_ASSERT(m_caseType < CASE_LAST); 1476 DE_ASSERT(m_interpolation < INTERPOLATE_LAST); 1477 } 1478 1479 void NegativeCompileInterpolationCase::init (void) 1480 { 1481 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_shader_multisample_interpolation") && !glu::contextSupports(m_context.getRenderContext().getType(), glu::ApiType::es(3, 2))) 1482 TCU_THROW(NotSupportedError, "Test requires GL_OES_shader_multisample_interpolation extension"); 1483 1484 m_testCtx.getLog() << tcu::TestLog::Message << "Trying to compile illegal shader, expecting compile to fail." << tcu::TestLog::EndMessage; 1485 } 1486 1487 NegativeCompileInterpolationCase::IterateResult NegativeCompileInterpolationCase::iterate (void) 1488 { 1489 const std::string source = genShaderSource(); 1490 glu::Shader shader (m_context.getRenderContext(), glu::SHADERTYPE_FRAGMENT); 1491 const char* const sourceStrPtr = source.c_str(); 1492 1493 m_testCtx.getLog() << tcu::TestLog::Message 1494 << "Fragment shader source:" 1495 << tcu::TestLog::EndMessage 1496 << tcu::TestLog::KernelSource(source); 1497 1498 shader.setSources(1, &sourceStrPtr, DE_NULL); 1499 shader.compile(); 1500 1501 m_testCtx.getLog() << tcu::TestLog::Message 1502 << "Info log:" 1503 << tcu::TestLog::EndMessage 1504 << tcu::TestLog::KernelSource(shader.getInfoLog()); 1505 1506 if (shader.getCompileStatus()) 1507 { 1508 m_testCtx.getLog() << tcu::TestLog::Message << "ERROR: Illegal shader compiled successfully." << tcu::TestLog::EndMessage; 1509 m_testCtx.setTestResult(QP_TEST_RESULT_FAIL, "Unexpected compile status"); 1510 } 1511 else 1512 { 1513 m_testCtx.getLog() << tcu::TestLog::Message << "Compile failed as expected." << tcu::TestLog::EndMessage; 1514 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 1515 } 1516 return STOP; 1517 } 1518 1519 std::string NegativeCompileInterpolationCase::genShaderSource (void) const 1520 { 1521 std::ostringstream buf; 1522 std::string interpolation; 1523 const char* interpolationTemplate; 1524 const char* description; 1525 const char* globalDeclarations = ""; 1526 const char* localDeclarations = ""; 1527 const char* interpolationTarget = ""; 1528 const char* postSelector = ""; 1529 1530 switch (m_caseType) 1531 { 1532 case CASE_VEC4_IDENTITY_SWIZZLE: 1533 globalDeclarations = "in highp vec4 v_var;\n"; 1534 interpolationTarget = "v_var.xyzw"; 1535 description = "component selection is illegal"; 1536 break; 1537 1538 case CASE_VEC4_CROP_SWIZZLE: 1539 globalDeclarations = "in highp vec4 v_var;\n"; 1540 interpolationTarget = "v_var.xy"; 1541 postSelector = ".x"; 1542 description = "component selection is illegal"; 1543 break; 1544 1545 case CASE_VEC4_MIXED_SWIZZLE: 1546 globalDeclarations = "in highp vec4 v_var;\n"; 1547 interpolationTarget = "v_var.yzxw"; 1548 description = "component selection is illegal"; 1549 break; 1550 1551 case CASE_INTERPOLATE_IVEC4: 1552 globalDeclarations = "flat in highp ivec4 v_var;\n"; 1553 interpolationTarget = "v_var"; 1554 description = "no overload for ivec"; 1555 break; 1556 1557 case CASE_INTERPOLATE_UVEC4: 1558 globalDeclarations = "flat in highp uvec4 v_var;\n"; 1559 interpolationTarget = "v_var"; 1560 description = "no overload for uvec"; 1561 break; 1562 1563 case CASE_INTERPOLATE_ARRAY: 1564 globalDeclarations = "in highp float v_var[2];\n"; 1565 interpolationTarget = "v_var"; 1566 postSelector = "[1]"; 1567 description = "no overload for arrays"; 1568 break; 1569 1570 case CASE_INTERPOLATE_STRUCT: 1571 case CASE_INTERPOLATE_STRUCT_MEMBER: 1572 globalDeclarations = "struct S\n" 1573 "{\n" 1574 " highp float a;\n" 1575 " highp float b;\n" 1576 "};\n" 1577 "in S v_var;\n"; 1578 1579 interpolationTarget = (m_caseType == CASE_INTERPOLATE_STRUCT) ? ("v_var") : ("v_var.a"); 1580 postSelector = (m_caseType == CASE_INTERPOLATE_STRUCT) ? (".a") : (""); 1581 description = (m_caseType == CASE_INTERPOLATE_STRUCT) ? ("no overload for this type") : ("<interpolant> is not an input variable (just a member of)"); 1582 break; 1583 1584 case CASE_INTERPOLATE_LOCAL: 1585 localDeclarations = " highp vec4 local_var = gl_FragCoord;\n"; 1586 interpolationTarget = "local_var"; 1587 description = "<interpolant> is not an input variable"; 1588 break; 1589 1590 case CASE_INTERPOLATE_GLOBAL: 1591 globalDeclarations = "highp vec4 global_var;\n"; 1592 localDeclarations = " global_var = gl_FragCoord;\n"; 1593 interpolationTarget = "global_var"; 1594 description = "<interpolant> is not an input variable"; 1595 break; 1596 1597 case CASE_INTERPOLATE_CONSTANT: 1598 globalDeclarations = "const highp vec4 const_var = vec4(0.2);\n"; 1599 interpolationTarget = "const_var"; 1600 description = "<interpolant> is not an input variable"; 1601 break; 1602 1603 default: 1604 DE_ASSERT(false); 1605 return ""; 1606 } 1607 1608 switch (m_interpolation) 1609 { 1610 case INTERPOLATE_AT_SAMPLE: 1611 interpolationTemplate = "interpolateAtSample(${TARGET}, 0)${POST_SELECTOR}"; 1612 break; 1613 1614 case INTERPOLATE_AT_CENTROID: 1615 interpolationTemplate = "interpolateAtCentroid(${TARGET})${POST_SELECTOR}"; 1616 break; 1617 1618 case INTERPOLATE_AT_OFFSET: 1619 interpolationTemplate = "interpolateAtOffset(${TARGET}, vec2(0.2, 0.2))${POST_SELECTOR}"; 1620 break; 1621 1622 default: 1623 DE_ASSERT(false); 1624 return ""; 1625 } 1626 1627 { 1628 std::map<std::string, std::string> args; 1629 args["TARGET"] = interpolationTarget; 1630 args["POST_SELECTOR"] = postSelector; 1631 1632 interpolation = tcu::StringTemplate(interpolationTemplate).specialize(args); 1633 } 1634 1635 buf << glu::getGLSLVersionDeclaration(glu::getContextTypeGLSLVersion(m_context.getRenderContext().getType())) << "\n" 1636 << "${GLSL_EXT_SHADER_MULTISAMPLE_INTERPOLATION}" 1637 << globalDeclarations 1638 << "layout(location = 0) out mediump vec4 fragColor;\n" 1639 "void main (void)\n" 1640 "{\n" 1641 << localDeclarations 1642 << " fragColor = vec4(" << interpolation << "); // " << description << "\n" 1643 "}\n"; 1644 1645 return specializeShader(buf.str(), m_context.getRenderContext().getType()); 1646 } 1647 1648 } // anonymous 1649 1650 ShaderMultisampleInterpolationTests::ShaderMultisampleInterpolationTests (Context& context) 1651 : TestCaseGroup(context, "multisample_interpolation", "Test multisample interpolation") 1652 { 1653 } 1654 1655 ShaderMultisampleInterpolationTests::~ShaderMultisampleInterpolationTests (void) 1656 { 1657 } 1658 1659 void ShaderMultisampleInterpolationTests::init (void) 1660 { 1661 using namespace MultisampleShaderRenderUtil; 1662 1663 static const struct RenderTarget 1664 { 1665 const char* name; 1666 const char* desc; 1667 int numSamples; 1668 MultisampleRenderCase::RenderTarget target; 1669 } targets[] = 1670 { 1671 { "default_framebuffer", "Test with default framebuffer", 0, MultisampleRenderCase::TARGET_DEFAULT }, 1672 { "singlesample_texture", "Test with singlesample texture", 0, MultisampleRenderCase::TARGET_TEXTURE }, 1673 { "multisample_texture_1", "Test with multisample texture", 1, MultisampleRenderCase::TARGET_TEXTURE }, 1674 { "multisample_texture_2", "Test with multisample texture", 2, MultisampleRenderCase::TARGET_TEXTURE }, 1675 { "multisample_texture_4", "Test with multisample texture", 4, MultisampleRenderCase::TARGET_TEXTURE }, 1676 { "multisample_texture_8", "Test with multisample texture", 8, MultisampleRenderCase::TARGET_TEXTURE }, 1677 { "multisample_texture_16", "Test with multisample texture", 16, MultisampleRenderCase::TARGET_TEXTURE }, 1678 { "singlesample_rbo", "Test with singlesample rbo", 0, MultisampleRenderCase::TARGET_RENDERBUFFER }, 1679 { "multisample_rbo_1", "Test with multisample rbo", 1, MultisampleRenderCase::TARGET_RENDERBUFFER }, 1680 { "multisample_rbo_2", "Test with multisample rbo", 2, MultisampleRenderCase::TARGET_RENDERBUFFER }, 1681 { "multisample_rbo_4", "Test with multisample rbo", 4, MultisampleRenderCase::TARGET_RENDERBUFFER }, 1682 { "multisample_rbo_8", "Test with multisample rbo", 8, MultisampleRenderCase::TARGET_RENDERBUFFER }, 1683 { "multisample_rbo_16", "Test with multisample rbo", 16, MultisampleRenderCase::TARGET_RENDERBUFFER }, 1684 }; 1685 1686 static const struct 1687 { 1688 const char* name; 1689 const char* description; 1690 NegativeCompileInterpolationCase::CaseType caseType; 1691 } negativeCompileCases[] = 1692 { 1693 { "vec4_identity_swizzle", "use identity swizzle", NegativeCompileInterpolationCase::CASE_VEC4_IDENTITY_SWIZZLE }, 1694 { "vec4_crop_swizzle", "use cropped identity swizzle", NegativeCompileInterpolationCase::CASE_VEC4_CROP_SWIZZLE }, 1695 { "vec4_mixed_swizzle", "use swizzle", NegativeCompileInterpolationCase::CASE_VEC4_MIXED_SWIZZLE }, 1696 { "interpolate_ivec4", "interpolate integer variable", NegativeCompileInterpolationCase::CASE_INTERPOLATE_IVEC4 }, 1697 { "interpolate_uvec4", "interpolate integer variable", NegativeCompileInterpolationCase::CASE_INTERPOLATE_UVEC4 }, 1698 { "interpolate_array", "interpolate whole array", NegativeCompileInterpolationCase::CASE_INTERPOLATE_ARRAY }, 1699 { "interpolate_struct", "interpolate whole struct", NegativeCompileInterpolationCase::CASE_INTERPOLATE_STRUCT }, 1700 { "interpolate_struct_member", "interpolate struct member", NegativeCompileInterpolationCase::CASE_INTERPOLATE_STRUCT_MEMBER }, 1701 { "interpolate_local", "interpolate local variable", NegativeCompileInterpolationCase::CASE_INTERPOLATE_LOCAL }, 1702 { "interpolate_global", "interpolate global variable", NegativeCompileInterpolationCase::CASE_INTERPOLATE_GLOBAL }, 1703 { "interpolate_constant", "interpolate constant variable", NegativeCompileInterpolationCase::CASE_INTERPOLATE_CONSTANT }, 1704 }; 1705 1706 // .sample_qualifier 1707 { 1708 tcu::TestCaseGroup* const sampleQualifierGroup = new tcu::TestCaseGroup(m_testCtx, "sample_qualifier", "Test sample qualifier"); 1709 addChild(sampleQualifierGroup); 1710 1711 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1712 sampleQualifierGroup->addChild(new SampleQualifierRenderCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target)); 1713 } 1714 1715 // .interpolate_at_sample 1716 { 1717 tcu::TestCaseGroup* const interpolateAtSampleGroup = new tcu::TestCaseGroup(m_testCtx, "interpolate_at_sample", "Test interpolateAtSample"); 1718 addChild(interpolateAtSampleGroup); 1719 1720 // .static_sample_number 1721 { 1722 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "static_sample_number", "Test interpolateAtSample sample number"); 1723 interpolateAtSampleGroup->addChild(group); 1724 1725 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1726 group->addChild(new InterpolateAtSampleRenderCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, InterpolateAtSampleRenderCase::INDEXING_STATIC)); 1727 } 1728 1729 // .dynamic_sample_number 1730 { 1731 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "dynamic_sample_number", "Test interpolateAtSample sample number"); 1732 interpolateAtSampleGroup->addChild(group); 1733 1734 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1735 group->addChild(new InterpolateAtSampleRenderCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, InterpolateAtSampleRenderCase::INDEXING_DYNAMIC)); 1736 } 1737 1738 // .non_multisample_buffer 1739 { 1740 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "non_multisample_buffer", "Test interpolateAtSample with non-multisample buffers"); 1741 interpolateAtSampleGroup->addChild(group); 1742 1743 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1744 if (targets[targetNdx].numSamples == 0) 1745 group->addChild(new SingleSampleInterpolateAtSampleCase(m_context, std::string("sample_0_").append(targets[targetNdx].name).c_str(), targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, SingleSampleInterpolateAtSampleCase::SAMPLE_0)); 1746 1747 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1748 if (targets[targetNdx].numSamples == 0) 1749 group->addChild(new SingleSampleInterpolateAtSampleCase(m_context, std::string("sample_n_").append(targets[targetNdx].name).c_str(), targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, SingleSampleInterpolateAtSampleCase::SAMPLE_N)); 1750 } 1751 1752 // .centroid_qualifier 1753 { 1754 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "centroid_qualified", "Test interpolateAtSample with centroid qualified varying"); 1755 interpolateAtSampleGroup->addChild(group); 1756 1757 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1758 group->addChild(new CentroidQualifierAtSampleCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target)); 1759 } 1760 1761 // .at_sample_id 1762 { 1763 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "at_sample_id", "Test interpolateAtSample at current sample id"); 1764 interpolateAtSampleGroup->addChild(group); 1765 1766 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1767 group->addChild(new InterpolateAtSampleIDCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target)); 1768 } 1769 1770 // .negative 1771 { 1772 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "negative", "interpolateAtSample negative tests"); 1773 interpolateAtSampleGroup->addChild(group); 1774 1775 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(negativeCompileCases); ++ndx) 1776 group->addChild(new NegativeCompileInterpolationCase(m_context, 1777 negativeCompileCases[ndx].name, 1778 negativeCompileCases[ndx].description, 1779 negativeCompileCases[ndx].caseType, 1780 NegativeCompileInterpolationCase::INTERPOLATE_AT_SAMPLE)); 1781 } 1782 } 1783 1784 // .interpolate_at_centroid 1785 { 1786 tcu::TestCaseGroup* const methodGroup = new tcu::TestCaseGroup(m_testCtx, "interpolate_at_centroid", "Test interpolateAtCentroid"); 1787 addChild(methodGroup); 1788 1789 // .consistency 1790 { 1791 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "consistency", "Test interpolateAtCentroid return value is consistent to centroid qualified value"); 1792 methodGroup->addChild(group); 1793 1794 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1795 group->addChild(new InterpolateAtCentroidCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, InterpolateAtCentroidCase::TEST_CONSISTENCY)); 1796 } 1797 1798 // .array_element 1799 { 1800 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "array_element", "Test interpolateAtCentroid with array element"); 1801 methodGroup->addChild(group); 1802 1803 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1804 group->addChild(new InterpolateAtCentroidCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, InterpolateAtCentroidCase::TEST_ARRAY_ELEMENT)); 1805 } 1806 1807 // .negative 1808 { 1809 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "negative", "interpolateAtCentroid negative tests"); 1810 methodGroup->addChild(group); 1811 1812 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(negativeCompileCases); ++ndx) 1813 group->addChild(new NegativeCompileInterpolationCase(m_context, 1814 negativeCompileCases[ndx].name, 1815 negativeCompileCases[ndx].description, 1816 negativeCompileCases[ndx].caseType, 1817 NegativeCompileInterpolationCase::INTERPOLATE_AT_CENTROID)); 1818 } 1819 } 1820 1821 // .interpolate_at_offset 1822 { 1823 static const struct TestConfig 1824 { 1825 const char* name; 1826 InterpolateAtOffsetCase::TestType type; 1827 } configs[] = 1828 { 1829 { "no_qualifiers", InterpolateAtOffsetCase::TEST_QUALIFIER_NONE }, 1830 { "centroid_qualifier", InterpolateAtOffsetCase::TEST_QUALIFIER_CENTROID }, 1831 { "sample_qualifier", InterpolateAtOffsetCase::TEST_QUALIFIER_SAMPLE }, 1832 }; 1833 1834 tcu::TestCaseGroup* const methodGroup = new tcu::TestCaseGroup(m_testCtx, "interpolate_at_offset", "Test interpolateAtOffset"); 1835 addChild(methodGroup); 1836 1837 // .no_qualifiers 1838 // .centroid_qualifier 1839 // .sample_qualifier 1840 for (int configNdx = 0; configNdx < DE_LENGTH_OF_ARRAY(configs); ++configNdx) 1841 { 1842 tcu::TestCaseGroup* const qualifierGroup = new tcu::TestCaseGroup(m_testCtx, configs[configNdx].name, "Test interpolateAtOffset with qualified/non-qualified varying"); 1843 methodGroup->addChild(qualifierGroup); 1844 1845 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1846 qualifierGroup->addChild(new InterpolateAtOffsetCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, configs[configNdx].type)); 1847 } 1848 1849 // .at_sample_position 1850 { 1851 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "at_sample_position", "Test interpolateAtOffset at sample position"); 1852 methodGroup->addChild(group); 1853 1854 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1855 group->addChild(new InterpolateAtSamplePositionCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target)); 1856 } 1857 1858 // .array_element 1859 { 1860 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "array_element", "Test interpolateAtOffset with array element"); 1861 methodGroup->addChild(group); 1862 1863 for (int targetNdx = 0; targetNdx < DE_LENGTH_OF_ARRAY(targets); ++targetNdx) 1864 group->addChild(new InterpolateAtOffsetCase(m_context, targets[targetNdx].name, targets[targetNdx].desc, targets[targetNdx].numSamples, targets[targetNdx].target, InterpolateAtOffsetCase::TEST_ARRAY_ELEMENT)); 1865 } 1866 1867 // .negative 1868 { 1869 tcu::TestCaseGroup* const group = new tcu::TestCaseGroup(m_testCtx, "negative", "interpolateAtOffset negative tests"); 1870 methodGroup->addChild(group); 1871 1872 for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(negativeCompileCases); ++ndx) 1873 group->addChild(new NegativeCompileInterpolationCase(m_context, 1874 negativeCompileCases[ndx].name, 1875 negativeCompileCases[ndx].description, 1876 negativeCompileCases[ndx].caseType, 1877 NegativeCompileInterpolationCase::INTERPOLATE_AT_OFFSET)); 1878 } 1879 } 1880 } 1881 1882 } // Functional 1883 } // gles31 1884 } // deqp 1885
