es31cSampleShadingTests.cpp revision 48087f5f0eb08759ee763f98daf3b34becb74559
1/*------------------------------------------------------------------------- 2 * OpenGL Conformance Test Suite 3 * ----------------------------- 4 * 5 * Copyright (c) 2014-2016 The Khronos Group Inc. 6 * 7 * Licensed under the Apache License, Version 2.0 (the "License"); 8 * you may not use this file except in compliance with the License. 9 * You may obtain a copy of the License at 10 * 11 * http://www.apache.org/licenses/LICENSE-2.0 12 * 13 * Unless required by applicable law or agreed to in writing, software 14 * distributed under the License is distributed on an "AS IS" BASIS, 15 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 16 * See the License for the specific language governing permissions and 17 * limitations under the License. 18 * 19 *//*! 20 * \file 21 * \brief 22 *//*--------------------------------------------------------------------*/ 23 24#include "es31cSampleShadingTests.hpp" 25#include "deRandom.hpp" 26#include "deStringUtil.hpp" 27#include "gluContextInfo.hpp" 28#include "gluDrawUtil.hpp" 29#include "gluPixelTransfer.hpp" 30#include "gluShaderProgram.hpp" 31#include "glw.h" 32#include "glwFunctions.hpp" 33#include "tcuCommandLine.hpp" 34#include "tcuStringTemplate.hpp" 35#include "tcuSurface.hpp" 36#include "tcuTestLog.hpp" 37 38namespace tcu 39{ 40static bool operator<(tcu::Vec4 const& k1, tcu::Vec4 const& k2) 41{ 42 if (k1.y() < k2.y()) 43 { 44 return true; 45 } 46 else if (k1.y() == k2.y()) 47 { 48 return k1.x() < k2.x(); 49 } 50 else 51 { 52 return false; 53 } 54} 55} 56 57namespace glcts 58{ 59 60using tcu::TestLog; 61using std::string; 62using std::vector; 63using glcts::Context; 64 65static std::string specializeVersion(std::string const& source, glu::GLSLVersion version, std::string const& sampler, 66 std::string const& outType) 67{ 68 DE_ASSERT(version == glu::GLSL_VERSION_310_ES || version >= glu::GLSL_VERSION_400); 69 std::map<std::string, std::string> args; 70 args["VERSION_DECL"] = glu::getGLSLVersionDeclaration(version); 71 args["SAMPLER"] = sampler; 72 args["OUT_TYPE"] = outType; 73 return tcu::StringTemplate(source.c_str()).specialize(args); 74} 75 76class SampleShadingApiCaseGroup : public TestCaseGroup 77{ 78public: 79 SampleShadingApiCaseGroup(Context& context, glu::GLSLVersion glslVersion) 80 : TestCaseGroup(context, "api", "Basic API verification"), m_glslVersion(glslVersion) 81 { 82 } 83 84 void init(void) 85 { 86 addChild(new SampleShadingApiCase(m_context, m_glslVersion)); 87 } 88 89private: 90 class SampleShadingApiCase : public deqp::TestCase 91 { 92 public: 93 SampleShadingApiCase(Context& context, glu::GLSLVersion glslVersion); 94 ~SampleShadingApiCase(); 95 96 IterateResult iterate(); 97 98 protected: 99 glu::GLSLVersion m_glslVersion; 100 glw::glMinSampleShadingFunc m_pGLMinSampleShading; 101 }; 102 103 glu::GLSLVersion m_glslVersion; 104}; 105 106SampleShadingApiCaseGroup::SampleShadingApiCase::SampleShadingApiCase(Context& context, glu::GLSLVersion glslVersion) 107 : TestCase(context, "verify", ""), m_glslVersion(glslVersion) 108{ 109 DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion >= glu::GLSL_VERSION_400); 110} 111 112SampleShadingApiCaseGroup::SampleShadingApiCase::~SampleShadingApiCase() 113{ 114} 115 116SampleShadingApiCaseGroup::SampleShadingApiCase::IterateResult SampleShadingApiCaseGroup::SampleShadingApiCase:: 117 iterate() 118{ 119 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 120 bool isOk = true; 121 122 if (m_glslVersion == glu::GLSL_VERSION_310_ES && 123 !m_context.getContextInfo().isExtensionSupported("GL_OES_sample_shading")) 124 { 125 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "GL_OES_sample_shading"); 126 return STOP; 127 } 128 129 m_pGLMinSampleShading = gl.minSampleShading; 130 131 struct Test 132 { 133 GLfloat input; 134 GLfloat result; 135 } tests[] = { 136 { 0.0f, 0.0f }, { 0.5f, 0.5f }, { -1.0f, 0.0f }, { 2.0f, 1.0f }, 137 }; 138 for (int i = 0; i < DE_LENGTH_OF_ARRAY(tests); ++i) 139 { 140 m_pGLMinSampleShading(tests[i].input); 141 GLfloat result = -1.0f; 142 gl.getFloatv(GL_MIN_SAMPLE_SHADING_VALUE_OES, &result); 143 if (result != tests[i].result) 144 { 145 isOk = false; 146 } 147 } 148 149 gl.enable(GL_SAMPLE_SHADING_OES); 150 if (!gl.isEnabled(GL_SAMPLE_SHADING_OES)) 151 { 152 isOk = false; 153 } 154 gl.disable(GL_SAMPLE_SHADING_OES); 155 if (gl.isEnabled(GL_SAMPLE_SHADING_OES)) 156 { 157 isOk = false; 158 } 159 160 m_pGLMinSampleShading(0.0f); 161 162 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, isOk ? "Pass" : "Fail"); 163 return STOP; 164} 165 166class SampleShadingRenderCase : public TestCase 167{ 168public: 169 SampleShadingRenderCase(Context& context, const char* name, const char* description, glu::GLSLVersion glslVersion, 170 GLenum internalFormat, tcu::TextureFormat const& texFormat, const char* m_sampler, 171 const char* m_outType, GLfloat min, GLfloat max, const char* m_extension, 172 GLfloat sampleShading); 173 ~SampleShadingRenderCase(); 174 175 IterateResult iterate(); 176 177protected: 178 glu::GLSLVersion m_glslVersion; 179 glw::glMinSampleShadingFunc m_pGLMinSampleShading; 180 GLenum m_internalFormat; 181 tcu::TextureFormat m_texFormat; 182 std::string m_sampler; 183 std::string m_outType; 184 GLfloat m_min; 185 GLfloat m_max; 186 std::string m_extension; 187 GLfloat m_sampleShading; 188 189 enum 190 { 191 WIDTH = 16, 192 HEIGHT = 16, 193 MAX_SAMPLES = 4, 194 }; 195 196 int countUniquePixels(tcu::ConstPixelBufferAccess const& pixels); 197 int countUniquePixels(const std::vector<tcu::Vec4>& pixels); 198}; 199 200SampleShadingRenderCase::SampleShadingRenderCase(Context& context, const char* name, const char* description, 201 glu::GLSLVersion glslVersion, GLenum internalFormat, 202 tcu::TextureFormat const& texFormat, const char* sampler, 203 const char* outType, GLfloat min, GLfloat max, const char* extension, 204 GLfloat sampleShading) 205 : TestCase(context, name, description) 206 , m_glslVersion(glslVersion) 207 , m_internalFormat(internalFormat) 208 , m_texFormat(texFormat) 209 , m_sampler(sampler) 210 , m_outType(outType) 211 , m_min(min) 212 , m_max(max) 213 , m_extension(extension) 214 , m_sampleShading(sampleShading) 215{ 216 DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion >= glu::GLSL_VERSION_400); 217} 218 219SampleShadingRenderCase::~SampleShadingRenderCase() 220{ 221} 222 223SampleShadingRenderCase::IterateResult SampleShadingRenderCase::iterate() 224{ 225 TestLog& log = m_testCtx.getLog(); 226 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 227 bool isOk = true; 228 229 if (m_glslVersion == glu::GLSL_VERSION_310_ES && 230 !m_context.getContextInfo().isExtensionSupported("GL_OES_sample_shading")) 231 { 232 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "GL_OES_sample_shading"); 233 return STOP; 234 } 235 if (!m_extension.empty() && !m_context.getContextInfo().isExtensionSupported(m_extension.c_str())) 236 { 237 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, m_extension.c_str()); 238 return STOP; 239 } 240 241 m_pGLMinSampleShading = gl.minSampleShading; 242 243 GLint maxSamples = 0; 244 if (((m_texFormat.type == tcu::TextureFormat::FLOAT) && (m_texFormat.order == tcu::TextureFormat::RGBA)) || 245 ((m_texFormat.type == tcu::TextureFormat::FLOAT) && (m_texFormat.order == tcu::TextureFormat::RG)) || 246 ((m_texFormat.type == tcu::TextureFormat::FLOAT) && (m_texFormat.order == tcu::TextureFormat::R)) || 247 ((m_texFormat.type == tcu::TextureFormat::HALF_FLOAT) && (m_texFormat.order == tcu::TextureFormat::RGBA))) 248 { 249 gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, m_internalFormat, GL_SAMPLES, 1, &maxSamples); 250 if (maxSamples == 0) 251 { 252 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Multisample is not supported on this format"); 253 return STOP; 254 } 255 } 256 else if (m_texFormat.type == tcu::TextureFormat::SIGNED_INT8 || 257 m_texFormat.type == tcu::TextureFormat::UNSIGNED_INT8) 258 { 259 gl.getIntegerv(GL_MAX_INTEGER_SAMPLES, &maxSamples); 260 } 261 else 262 { 263 gl.getIntegerv(GL_MAX_SAMPLES, &maxSamples); 264 } 265 GLint samples = de::min<GLint>(maxSamples, MAX_SAMPLES); 266 267 GLuint tex; 268 gl.genTextures(1, &tex); 269 gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, tex); 270 gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, samples, m_internalFormat, WIDTH, HEIGHT, GL_FALSE); 271 272 GLuint fboMs; 273 gl.genFramebuffers(1, &fboMs); 274 gl.bindFramebuffer(GL_FRAMEBUFFER, fboMs); 275 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D_MULTISAMPLE, tex, 0); 276 gl.viewport(0, 0, WIDTH, HEIGHT); 277 278 m_pGLMinSampleShading(m_sampleShading); 279 gl.enable(GL_SAMPLE_SHADING_OES); 280 281 static const deUint16 quadIndices[] = { 0, 1, 2, 2, 1, 3 }; 282 283 { 284 static char const* vss = "${VERSION_DECL}\n" 285 "in highp vec2 a_position;\n" 286 "in highp vec4 a_color;\n" 287 "out highp vec4 v_color;\n" 288 "void main (void)\n" 289 "{\n" 290 " gl_Position = vec4(a_position, 0.0, 1.0);\n" 291 " v_color = a_color;\n" 292 "}\n"; 293 294 static char const* fss = "${VERSION_DECL}\n" 295 "in highp vec4 v_color;\n" 296 "layout(location = 0) out highp ${OUT_TYPE} o_color;\n" 297 "void main (void)\n" 298 "{\n" 299 " o_color = ${OUT_TYPE}(v_color.x, v_color.y, 0.0, 0.0);\n" 300 "}\n"; 301 302 glu::ShaderProgram program( 303 m_context.getRenderContext(), 304 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion, m_sampler, m_outType).c_str(), 305 specializeVersion(fss, m_glslVersion, m_sampler, m_outType).c_str())); 306 log << program; 307 if (!program.isOk()) 308 { 309 TCU_FAIL("Compile failed"); 310 } 311 312 const float position[] = { 313 -1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, 314 }; 315 const float color[] = { 316 m_min, m_min, 0.0f, 1.0f, m_min, m_max, 0.0f, 1.0f, m_max, m_min, 0.0f, 1.0f, m_max, m_max, 0.0f, 1.0f, 317 }; 318 319 gl.useProgram(program.getProgram()); 320 321 glu::VertexArrayBinding vertexArrays[] = { 322 glu::va::Float("a_position", 2, 4, 0, &position[0]), glu::va::Float("a_color", 4, 4, 0, &color[0]), 323 }; 324 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), 325 &vertexArrays[0], glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0])); 326 327 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw quad"); 328 } 329 m_pGLMinSampleShading(0.0f); 330 gl.disable(GL_SAMPLE_SHADING_OES); 331 gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer()); 332 gl.deleteFramebuffers(1, &fboMs); 333 334 GLsizei width = WIDTH * samples; 335 336 GLuint rbo; 337 gl.genRenderbuffers(1, &rbo); 338 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo); 339 gl.renderbufferStorage(GL_RENDERBUFFER, m_internalFormat, width, HEIGHT); 340 341 GLuint fbo; 342 gl.genFramebuffers(1, &fbo); 343 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); 344 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo); 345 gl.viewport(0, 0, width, HEIGHT); 346 347 { 348 static char const* vss = "${VERSION_DECL}\n" 349 "in highp vec2 a_position;\n" 350 "void main(void)\n" 351 "{\n" 352 " gl_Position = vec4(a_position, 0.0, 1.0);\n" 353 "}\n"; 354 355 static char const* fss = "${VERSION_DECL}\n" 356 "uniform highp ${SAMPLER} u_tex;\n" 357 "uniform int u_samples;\n" 358 "layout(location = 0) out highp ${OUT_TYPE} o_color;\n" 359 "void main(void)\n" 360 "{\n" 361 " ivec2 coord = ivec2(int(gl_FragCoord.x) / u_samples, gl_FragCoord.y);\n" 362 " int sampleId = int(gl_FragCoord.x) % u_samples;\n" 363 " o_color = texelFetch(u_tex, coord, sampleId);\n" 364 "}\n"; 365 366 glu::ShaderProgram program( 367 m_context.getRenderContext(), 368 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion, m_sampler, m_outType).c_str(), 369 specializeVersion(fss, m_glslVersion, m_sampler, m_outType).c_str())); 370 log << program; 371 if (!program.isOk()) 372 { 373 TCU_FAIL("Compile failed"); 374 } 375 376 float const position[] = { 377 -1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, 378 }; 379 380 gl.useProgram(program.getProgram()); 381 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_samples"), samples); 382 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_tex"), 0); 383 384 glu::VertexArrayBinding vertexArrays[] = { 385 glu::va::Float("a_position", 2, 4, 0, &position[0]), 386 }; 387 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), 388 &vertexArrays[0], glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0])); 389 390 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw quad"); 391 } 392 393 tcu::TextureLevel results(m_texFormat, width, HEIGHT); 394 tcu::PixelBufferAccess pixels = results.getAccess(); 395 std::vector<tcu::Vec4> result(pixels.getHeight() * pixels.getWidth()); 396 int uniquePixels; 397 398 if (pixels.getFormat().type == tcu::TextureFormat::SIGNED_INT8) 399 { 400 std::vector<GLint> data(pixels.getHeight() * pixels.getWidth() * 4); 401 gl.readPixels(0, 0, pixels.getWidth(), pixels.getHeight(), GL_RGBA_INTEGER, GL_INT, &data[0]); 402 for (unsigned int i = 0; i < data.size(); i += 4) 403 { 404 result[i / 4] = 405 tcu::Vec4((GLfloat)data[i], (GLfloat)data[i + 1], (GLfloat)data[i + 2], (GLfloat)data[i + 3]); 406 } 407 uniquePixels = countUniquePixels(result); 408 } 409 else if (pixels.getFormat().type == tcu::TextureFormat::UNSIGNED_INT8) 410 { 411 std::vector<GLuint> data(pixels.getHeight() * pixels.getWidth() * 4); 412 gl.readPixels(0, 0, pixels.getWidth(), pixels.getHeight(), GL_RGBA_INTEGER, GL_UNSIGNED_INT, &data[0]); 413 for (unsigned int i = 0; i < data.size(); i += 4) 414 { 415 result[i / 4] = 416 tcu::Vec4((GLfloat)data[i], (GLfloat)data[i + 1], (GLfloat)data[i + 2], (GLfloat)data[i + 3]); 417 } 418 uniquePixels = countUniquePixels(result); 419 } 420 else 421 { 422 glu::readPixels(m_context.getRenderContext(), 0, 0, pixels); 423 uniquePixels = countUniquePixels(pixels); 424 } 425 int expectedUnique = WIDTH * HEIGHT * (de::clamp(int(float(samples) * m_sampleShading), 1, samples)); 426 if (uniquePixels < expectedUnique) 427 { 428 isOk = false; 429 } 430 431 gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer()); 432 gl.deleteFramebuffers(1, &fbo); 433 434 gl.bindRenderbuffer(GL_RENDERBUFFER, 0); 435 gl.deleteRenderbuffers(1, &rbo); 436 437 gl.bindTexture(GL_TEXTURE_2D_MULTISAMPLE, 0); 438 gl.deleteTextures(1, &tex); 439 440 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, isOk ? "Pass" : "Fail"); 441 return STOP; 442} 443 444int SampleShadingRenderCase::countUniquePixels(tcu::ConstPixelBufferAccess const& pixels) 445{ 446 std::set<tcu::Vec4> uniquePixels; 447 448 for (int y = 0; y < pixels.getHeight(); ++y) 449 { 450 for (int x = 0; x < pixels.getWidth(); ++x) 451 { 452 uniquePixels.insert(pixels.getPixel(x, y)); 453 } 454 } 455 456 return (int)uniquePixels.size(); 457} 458 459int SampleShadingRenderCase::countUniquePixels(const std::vector<tcu::Vec4>& pixels) 460{ 461 std::set<tcu::Vec4> uniquePixels; 462 463 for (unsigned int i = 0; i < pixels.size(); ++i) 464 { 465 uniquePixels.insert(pixels[i]); 466 } 467 468 return (int)uniquePixels.size(); 469} 470 471class SampleShadingRenderFormatTests : public glcts::TestCaseGroup 472{ 473public: 474 SampleShadingRenderFormatTests(glcts::Context& context, glu::GLSLVersion glslVersion, GLenum internalFormat, 475 const char* format, tcu::TextureFormat const& texFormat, const char* sampler, 476 const char* outType, GLfloat min, GLfloat max, const char* extension = ""); 477 ~SampleShadingRenderFormatTests(void); 478 479 void init(void); 480 481private: 482 SampleShadingRenderFormatTests(const SampleShadingTests& other); 483 SampleShadingRenderFormatTests& operator=(const SampleShadingTests& other); 484 485 glu::GLSLVersion m_glslVersion; 486 GLenum m_internalFormat; 487 tcu::TextureFormat m_texFormat; 488 std::string m_sampler; 489 std::string m_outType; 490 GLfloat m_min; 491 GLfloat m_max; 492 std::string m_extension; 493}; 494 495SampleShadingRenderFormatTests::SampleShadingRenderFormatTests(Context& context, glu::GLSLVersion glslVersion, 496 GLenum internalFormat, const char* format, 497 tcu::TextureFormat const& texFormat, const char* sampler, 498 const char* outType, GLfloat min, GLfloat max, 499 const char* extension) 500 : TestCaseGroup(context, format, "") 501 , m_glslVersion(glslVersion) 502 , m_internalFormat(internalFormat) 503 , m_texFormat(texFormat) 504 , m_sampler(sampler) 505 , m_outType(outType) 506 , m_min(min) 507 , m_max(max) 508 , m_extension(extension) 509{ 510} 511 512SampleShadingRenderFormatTests::~SampleShadingRenderFormatTests(void) 513{ 514} 515 516void SampleShadingRenderFormatTests::init(void) 517{ 518 // sample_shading.render.full 519 addChild(new SampleShadingRenderCase(m_context, "full", "Sample shader functionality", m_glslVersion, 520 m_internalFormat, m_texFormat, m_sampler.c_str(), m_outType.c_str(), m_min, 521 m_max, m_extension.c_str(), 1.0)); 522 // sample_shading.render.half 523 addChild(new SampleShadingRenderCase(m_context, "half", "Sample shader functionality", m_glslVersion, 524 m_internalFormat, m_texFormat, m_sampler.c_str(), m_outType.c_str(), m_min, 525 m_max, m_extension.c_str(), 0.5)); 526 // sample_shading.render.none 527 addChild(new SampleShadingRenderCase(m_context, "none", "Sample shader functionality", m_glslVersion, 528 m_internalFormat, m_texFormat, m_sampler.c_str(), m_outType.c_str(), m_min, 529 m_max, m_extension.c_str(), 0.0)); 530} 531 532class SampleShadingRenderTests : public glcts::TestCaseGroup 533{ 534public: 535 SampleShadingRenderTests(glcts::Context& context, glu::GLSLVersion glslVersion); 536 ~SampleShadingRenderTests(void); 537 538 void init(void); 539 540private: 541 SampleShadingRenderTests(const SampleShadingTests& other); 542 SampleShadingRenderTests& operator=(const SampleShadingTests& other); 543 544 glu::GLSLVersion m_glslVersion; 545}; 546 547SampleShadingRenderTests::SampleShadingRenderTests(Context& context, glu::GLSLVersion glslVersion) 548 : TestCaseGroup(context, "render", "Sample Shading render tests"), m_glslVersion(glslVersion) 549{ 550} 551 552SampleShadingRenderTests::~SampleShadingRenderTests(void) 553{ 554} 555 556void SampleShadingRenderTests::init(void) 557{ 558 // sample_shading.render.rgba8 559 addChild(new SampleShadingRenderFormatTests( 560 m_context, m_glslVersion, GL_RGBA8, "rgba8", 561 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), "sampler2DMS", "vec4", 0.0, 1.0)); 562 // sample_shading.render.rgba8i 563 addChild(new SampleShadingRenderFormatTests( 564 m_context, m_glslVersion, GL_RGBA8I, "rgba8i", 565 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), "isampler2DMS", "ivec4", -128.0, 566 127.0)); 567 // sample_shading.render.rgba8ui 568 addChild(new SampleShadingRenderFormatTests( 569 m_context, m_glslVersion, GL_RGBA8UI, "rgba8ui", 570 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), "usampler2DMS", "uvec4", 0.0, 571 255.0)); 572 // sample_shading.render.rgba32f 573 const char* extension = 574 (glu::isContextTypeES(m_context.getRenderContext().getType())) ? "GL_EXT_color_buffer_float" : ""; 575 addChild(new SampleShadingRenderFormatTests(m_context, m_glslVersion, GL_RGBA32F, "rgba32f", 576 tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), 577 "sampler2DMS", "vec4", 0.0, 1.0, extension)); 578} 579 580SampleShadingTests::SampleShadingTests(Context& context, glu::GLSLVersion glslVersion) 581 : TestCaseGroup(context, "sample_shading", "Sample Shading tests"), m_glslVersion(glslVersion) 582{ 583} 584 585SampleShadingTests::~SampleShadingTests(void) 586{ 587} 588 589void SampleShadingTests::init(void) 590{ 591 // sample_shading.api 592 addChild(new SampleShadingApiCaseGroup(m_context, m_glslVersion)); 593 // sample_shading.render 594 addChild(new SampleShadingRenderTests(m_context, m_glslVersion)); 595} 596 597} // glcts 598