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 "glcSampleVariablesTests.hpp" 25 #include "deMath.h" 26 #include "deRandom.hpp" 27 #include "deStringUtil.hpp" 28 #include "gluContextInfo.hpp" 29 #include "gluDrawUtil.hpp" 30 #include "gluPixelTransfer.hpp" 31 #include "gluShaderProgram.hpp" 32 #include "glw.h" 33 #include "glwFunctions.hpp" 34 #include "tcuCommandLine.hpp" 35 #include "tcuStringTemplate.hpp" 36 #include "tcuSurface.hpp" 37 #include "tcuTestLog.hpp" 38 39 namespace tcu 40 { 41 static bool operator<(tcu::Vec4 const& k1, tcu::Vec4 const& k2) 42 { 43 if (k1.y() < k2.y()) 44 { 45 return true; 46 } 47 else if (k1.y() == k2.y()) 48 { 49 return k1.x() < k2.x(); 50 } 51 else 52 { 53 return false; 54 } 55 } 56 } 57 58 namespace deqp 59 { 60 61 using tcu::TestLog; 62 using std::string; 63 using std::vector; 64 65 static std::string specializeVersion(std::string const& source, glu::GLSLVersion version, 66 std::string const& sampler = "", 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 if (version == glu::GLSL_VERSION_310_ES) 74 { 75 args["OES_SV_RQ"] = "#extension GL_OES_sample_variables : require\n"; 76 args["OES_SV_EN"] = "#extension GL_OES_sample_variables : enable\n"; 77 } 78 else 79 { 80 args["OES_SV_RQ"] = ""; 81 args["OES_SV_EN"] = ""; 82 } 83 return tcu::StringTemplate(source.c_str()).specialize(args); 84 } 85 86 class SampleShadingExtensionCase : public TestCase 87 { 88 public: 89 SampleShadingExtensionCase(Context& context, const char* name, const char* description, 90 glu::GLSLVersion glslVersion); 91 ~SampleShadingExtensionCase(); 92 93 IterateResult iterate(); 94 95 protected: 96 glu::GLSLVersion m_glslVersion; 97 }; 98 99 SampleShadingExtensionCase::SampleShadingExtensionCase(Context& context, const char* name, const char* description, 100 glu::GLSLVersion glslVersion) 101 : TestCase(context, name, description), m_glslVersion(glslVersion) 102 { 103 DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES); 104 } 105 106 SampleShadingExtensionCase::~SampleShadingExtensionCase() 107 { 108 } 109 110 SampleShadingExtensionCase::IterateResult SampleShadingExtensionCase::iterate() 111 { 112 TestLog& log = m_testCtx.getLog(); 113 114 if (!m_context.getContextInfo().isExtensionSupported("GL_OES_sample_variables")) 115 { 116 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "GL_OES_sample_variables"); 117 return STOP; 118 } 119 120 static char const* vss = "${VERSION_DECL}\n" 121 "in highp vec4 a_position;\n" 122 "void main()\n" 123 "{\n" 124 " gl_Position = a_position;\n" 125 "}\n"; 126 127 { 128 static char const* fss = "${VERSION_DECL}\n" 129 "${OES_SV_RQ}" 130 "out highp vec4 o_color;\n" 131 "void main()\n" 132 "{\n" 133 " for (int i = 0; i < (gl_MaxSamples + 31) / 32; ++i) {\n" 134 " gl_SampleMask[i] = gl_SampleMaskIn[i];\n" 135 " }\n" 136 " o_color = vec4(gl_SampleID, gl_SamplePosition.x, gl_SamplePosition.y, 1);\n" 137 "}\n"; 138 139 glu::ShaderProgram programRequire(m_context.getRenderContext(), 140 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion).c_str(), 141 specializeVersion(fss, m_glslVersion).c_str())); 142 log << programRequire; 143 if (!programRequire.isOk()) 144 { 145 TCU_FAIL("Compile failed"); 146 } 147 } 148 149 { 150 static char const* fss = "${VERSION_DECL}\n" 151 "${OES_SV_EN}" 152 "out highp vec4 o_color;\n" 153 "void main()\n" 154 "{\n" 155 "#if !GL_OES_sample_variables\n" 156 " this is broken\n" 157 "#endif\n" 158 " for (int i = 0; i < (gl_MaxSamples + 31) / 32; ++i) {\n" 159 " gl_SampleMask[i] = gl_SampleMaskIn[i];\n" 160 " }\n" 161 " o_color = vec4(gl_SampleID, gl_SamplePosition.x, gl_SamplePosition.y, 1);\n" 162 "}\n"; 163 164 glu::ShaderProgram programEnable(m_context.getRenderContext(), 165 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion).c_str(), 166 specializeVersion(fss, m_glslVersion).c_str())); 167 log << programEnable; 168 if (!programEnable.isOk()) 169 { 170 TCU_FAIL("Compile failed"); 171 } 172 } 173 174 m_testCtx.setTestResult(QP_TEST_RESULT_PASS, "Pass"); 175 return STOP; 176 } 177 178 class SampleShadingMaskCase : public TestCase 179 { 180 public: 181 SampleShadingMaskCase(Context& context, const char* name, const char* description, glu::GLSLVersion glslVersion, 182 GLenum internalFormat, tcu::TextureFormat const& texFormat, const char* sampler, 183 const char* outType, GLint samples, GLint sampleMask); 184 ~SampleShadingMaskCase(); 185 186 IterateResult iterate(); 187 188 protected: 189 glu::GLSLVersion m_glslVersion; 190 GLenum m_internalFormat; 191 tcu::TextureFormat m_texFormat; 192 std::string m_sampler; 193 std::string m_outType; 194 GLint m_samples; 195 GLint m_sampleMask; 196 197 enum 198 { 199 WIDTH = 16, 200 HEIGHT = 16, 201 MAX_SAMPLES = 4, 202 }; 203 }; 204 205 SampleShadingMaskCase::SampleShadingMaskCase(Context& context, const char* name, const char* description, 206 glu::GLSLVersion glslVersion, GLenum internalFormat, 207 tcu::TextureFormat const& texFormat, const char* sampler, 208 const char* outType, GLint samples, GLint sampleMask) 209 : TestCase(context, name, description) 210 , m_glslVersion(glslVersion) 211 , m_internalFormat(internalFormat) 212 , m_texFormat(texFormat) 213 , m_sampler(sampler) 214 , m_outType(outType) 215 , m_samples(samples) 216 , m_sampleMask(sampleMask) 217 { 218 DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion >= glu::GLSL_VERSION_400); 219 } 220 221 SampleShadingMaskCase::~SampleShadingMaskCase() 222 { 223 } 224 225 SampleShadingMaskCase::IterateResult SampleShadingMaskCase::iterate() 226 { 227 TestLog& log = m_testCtx.getLog(); 228 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 229 bool isOk = true; 230 bool supportsRgba32f = false; 231 232 if (m_glslVersion == glu::GLSL_VERSION_310_ES && 233 !m_context.getContextInfo().isExtensionSupported("GL_OES_sample_variables")) 234 { 235 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "GL_OES_sample_variables"); 236 return STOP; 237 } 238 239 supportsRgba32f = isContextTypeGLCore(m_context.getRenderContext().getType()) ? 240 true : 241 (m_context.getContextInfo().isExtensionSupported("GL_EXT_color_buffer_float") || 242 m_context.getContextInfo().isExtensionSupported("GL_ARB_color_buffer_float")); 243 244 if (m_internalFormat == GL_RGBA32F && !supportsRgba32f) 245 { 246 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Internalformat rgba32f not supported"); 247 return STOP; 248 } 249 250 GLint maxSamples; 251 if (((m_texFormat.type == tcu::TextureFormat::FLOAT) && (m_texFormat.order == tcu::TextureFormat::RGBA)) || 252 ((m_texFormat.type == tcu::TextureFormat::FLOAT) && (m_texFormat.order == tcu::TextureFormat::RG)) || 253 ((m_texFormat.type == tcu::TextureFormat::FLOAT) && (m_texFormat.order == tcu::TextureFormat::R)) || 254 ((m_texFormat.type == tcu::TextureFormat::HALF_FLOAT) && (m_texFormat.order == tcu::TextureFormat::RGBA))) 255 { 256 gl.getInternalformativ(GL_TEXTURE_2D_MULTISAMPLE, m_internalFormat, GL_SAMPLES, 1, &maxSamples); 257 if (m_samples > maxSamples) 258 { 259 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, 260 "Test sample count greater than samples that the format supports"); 261 return STOP; 262 } 263 } 264 else if (m_texFormat.type == tcu::TextureFormat::SIGNED_INT8 || 265 m_texFormat.type == tcu::TextureFormat::UNSIGNED_INT8) 266 { 267 gl.getIntegerv(GL_MAX_INTEGER_SAMPLES, &maxSamples); 268 if (m_samples > maxSamples) 269 { 270 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Test sample count greater than MAX_INTEGER_SAMPLES"); 271 return STOP; 272 } 273 } 274 else 275 { 276 gl.getIntegerv(GL_MAX_SAMPLES, &maxSamples); 277 if (m_samples > maxSamples) 278 { 279 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Test sample count greater than MAX_SAMPLES"); 280 return STOP; 281 } 282 } 283 284 // Create a multisample texture, or a regular texture if samples is zero. 285 GLuint tex; 286 gl.genTextures(1, &tex); 287 GLenum target; 288 if (m_samples) 289 { 290 target = GL_TEXTURE_2D_MULTISAMPLE; 291 gl.bindTexture(target, tex); 292 gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, m_samples, m_internalFormat, WIDTH, HEIGHT, GL_FALSE); 293 } 294 else 295 { 296 target = GL_TEXTURE_2D; 297 gl.bindTexture(target, tex); 298 gl.texStorage2D(GL_TEXTURE_2D, 1, m_internalFormat, WIDTH, HEIGHT); 299 if (m_texFormat.type == tcu::TextureFormat::SIGNED_INT8 || 300 m_texFormat.type == tcu::TextureFormat::UNSIGNED_INT8 || m_texFormat.type == tcu::TextureFormat::FLOAT) 301 { 302 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST); 303 gl.texParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST); 304 } 305 } 306 307 // Create a framebuffer with the texture attached and clear to "green". 308 GLuint fboMs; 309 gl.genFramebuffers(1, &fboMs); 310 gl.bindFramebuffer(GL_FRAMEBUFFER, fboMs); 311 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, tex, 0); 312 gl.viewport(0, 0, WIDTH, HEIGHT); 313 if (m_texFormat.type == tcu::TextureFormat::SIGNED_INT8) 314 { 315 GLint color[4] = { 0, 1, 0, 1 }; 316 gl.clearBufferiv(GL_COLOR, 0, color); 317 } 318 else if (m_texFormat.type == tcu::TextureFormat::UNSIGNED_INT8) 319 { 320 GLuint color[4] = { 0, 1, 0, 1 }; 321 gl.clearBufferuiv(GL_COLOR, 0, color); 322 } 323 else 324 { 325 GLfloat color[4] = { 0.0f, 1.0f, 0.0f, 1.0f }; 326 gl.clearBufferfv(GL_COLOR, 0, color); 327 } 328 329 static deUint16 const quadIndices[] = { 0, 1, 2, 2, 1, 3 }; 330 331 { 332 // Draw a quad setting all samples to "red". We only expect "red" 333 // to be written if the sample mask bit for that sample is 1. 334 335 static char const* vss = "${VERSION_DECL}\n" 336 "in highp vec2 a_position;\n" 337 "void main()\n" 338 "{\n" 339 " gl_Position = vec4(a_position, 0.0, 1.0);\n" 340 "}\n"; 341 342 static char const* fss = "${VERSION_DECL}\n" 343 "${OES_SV_RQ}" 344 "layout(location = 0) out highp ${OUT_TYPE} o_color;\n" 345 "uniform int u_sampleMask;\n" 346 "void main()\n" 347 "{\n" 348 " for (int i = 0; i < (gl_NumSamples + 31) / 32; ++i) {\n" 349 " gl_SampleMask[i] = u_sampleMask & gl_SampleMaskIn[i];\n" 350 " }\n" 351 " o_color = ${OUT_TYPE}(1, 0, 0, 1);\n" 352 "}\n"; 353 354 glu::ShaderProgram program( 355 m_context.getRenderContext(), 356 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion, m_sampler, m_outType).c_str(), 357 specializeVersion(fss, m_glslVersion, m_sampler, m_outType).c_str())); 358 log << program; 359 if (!program.isOk()) 360 { 361 TCU_FAIL("Compile failed"); 362 } 363 364 static float const position[] = { 365 -1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, 366 }; 367 368 gl.useProgram(program.getProgram()); 369 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_sampleMask"), m_sampleMask); 370 371 glu::VertexArrayBinding vertexArrays[] = { 372 glu::va::Float("a_position", 2, 4, 0, &position[0]), 373 }; 374 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), 375 &vertexArrays[0], glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0])); 376 377 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw quad"); 378 } 379 380 gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer()); 381 gl.deleteFramebuffers(1, &fboMs); 382 383 GLsizei width = WIDTH * ((m_samples) ? m_samples : 1); 384 385 GLuint rbo; 386 gl.genRenderbuffers(1, &rbo); 387 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo); 388 gl.renderbufferStorage(GL_RENDERBUFFER, m_internalFormat, width, HEIGHT); 389 390 GLuint fbo; 391 gl.genFramebuffers(1, &fbo); 392 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); 393 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo); 394 gl.viewport(0, 0, width, HEIGHT); 395 396 { 397 // Resolve the multi-sample texture into a render-buffer sized such that 398 // the width can hold all samples of a pixel. 399 static char const* vss = "${VERSION_DECL}\n" 400 "in highp vec2 a_position;\n" 401 "void main(void)\n" 402 "{\n" 403 " gl_Position = vec4(a_position, 0.0, 1.0);\n" 404 "}\n"; 405 406 static char const* fss = "${VERSION_DECL}\n" 407 "uniform highp ${SAMPLER} u_tex;\n" 408 "uniform highp ${SAMPLER}MS u_texMS;\n" 409 "uniform int u_samples;\n" 410 "layout(location = 0) out highp ${OUT_TYPE} o_color;\n" 411 "void main(void)\n" 412 "{\n" 413 " if (u_samples > 0) {\n" 414 " ivec2 coord = ivec2(int(gl_FragCoord.x) / u_samples, gl_FragCoord.y);\n" 415 " int sampleId = int(gl_FragCoord.x) % u_samples;\n" 416 " o_color = texelFetch(u_texMS, coord, sampleId);\n" 417 " } else {\n" 418 " ivec2 coord = ivec2(gl_FragCoord.x, gl_FragCoord.y);\n" 419 " o_color = texelFetch(u_tex, coord, 0);\n" 420 " }\n" 421 "}\n"; 422 423 glu::ShaderProgram program( 424 m_context.getRenderContext(), 425 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion, m_sampler, m_outType).c_str(), 426 specializeVersion(fss, m_glslVersion, m_sampler, m_outType).c_str())); 427 log << program; 428 if (!program.isOk()) 429 { 430 TCU_FAIL("Compile failed"); 431 } 432 433 static float const position[] = { 434 -1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, 435 }; 436 437 gl.useProgram(program.getProgram()); 438 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_samples"), m_samples); 439 if (m_samples > 0) 440 { 441 // only MS sampler needed, TU 1 is not used 442 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_tex"), 1); 443 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_texMS"), 0); 444 } 445 else 446 { 447 // only non-MS sampler needed, TU 1 is not used 448 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_tex"), 0); 449 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_texMS"), 1); 450 } 451 452 glu::VertexArrayBinding vertexArrays[] = { 453 glu::va::Float("a_position", 2, 4, 0, &position[0]), 454 }; 455 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), 456 &vertexArrays[0], glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0])); 457 458 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw quad"); 459 } 460 461 tcu::TextureLevel results(m_texFormat, width, HEIGHT); 462 tcu::PixelBufferAccess pixels = results.getAccess(); 463 std::vector<tcu::Vec4> result(pixels.getHeight() * pixels.getWidth()); 464 465 if (pixels.getFormat().type == tcu::TextureFormat::SIGNED_INT8) 466 { 467 std::vector<GLint> data(pixels.getHeight() * pixels.getWidth() * 4); 468 gl.readPixels(0, 0, pixels.getWidth(), pixels.getHeight(), GL_RGBA_INTEGER, GL_INT, &data[0]); 469 for (unsigned int i = 0; i < data.size(); i += 4) 470 { 471 result[i / 4] = 472 tcu::Vec4((GLfloat)data[i], (GLfloat)data[i + 1], (GLfloat)data[i + 2], (GLfloat)data[i + 3]); 473 } 474 } 475 else if (pixels.getFormat().type == tcu::TextureFormat::UNSIGNED_INT8) 476 { 477 std::vector<GLuint> data(pixels.getHeight() * pixels.getWidth() * 4); 478 gl.readPixels(0, 0, pixels.getWidth(), pixels.getHeight(), GL_RGBA_INTEGER, GL_UNSIGNED_INT, &data[0]); 479 for (unsigned int i = 0; i < data.size(); i += 4) 480 { 481 result[i / 4] = 482 tcu::Vec4((GLfloat)data[i], (GLfloat)data[i + 1], (GLfloat)data[i + 2], (GLfloat)data[i + 3]); 483 } 484 } 485 else 486 { 487 glu::readPixels(m_context.getRenderContext(), 0, 0, pixels); 488 } 489 490 for (int y = 0; y < HEIGHT; ++y) 491 { 492 for (int x = 0; x < WIDTH; ++x) 493 { 494 GLint samples = (m_samples) ? m_samples : 1; 495 for (int sample = 0; sample < samples; ++sample) 496 { 497 tcu::Vec4 pixel; 498 if (pixels.getFormat().type == tcu::TextureFormat::SIGNED_INT8 || 499 pixels.getFormat().type == tcu::TextureFormat::UNSIGNED_INT8) 500 { 501 pixel = result[y * WIDTH + x * samples + sample]; 502 } 503 else 504 { 505 pixel = pixels.getPixel(x * samples + sample, y); 506 } 507 508 // Make sure only those samples where the sample mask bit is 509 // non-zero have the "red" pixel values. 510 if (!m_samples || (m_sampleMask & (1 << sample))) 511 { 512 if (pixel != tcu::Vec4(1.0f, 0.0f, 0.0f, 1.0f)) 513 { 514 isOk = false; 515 } 516 } 517 else 518 { 519 if (pixel != tcu::Vec4(0.0f, 1.0f, 0.0f, 1.0f)) 520 { 521 isOk = false; 522 } 523 } 524 } 525 } 526 } 527 528 gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer()); 529 gl.deleteFramebuffers(1, &fbo); 530 531 gl.bindRenderbuffer(GL_RENDERBUFFER, 0); 532 gl.deleteRenderbuffers(1, &rbo); 533 534 gl.bindTexture(target, 0); 535 gl.deleteTextures(1, &tex); 536 537 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, isOk ? "Pass" : "Fail"); 538 return STOP; 539 } 540 541 class SampleShadingPositionCase : public TestCase 542 { 543 public: 544 SampleShadingPositionCase(Context& context, const char* name, const char* description, glu::GLSLVersion glslVersion, 545 GLint samples, GLboolean fixedSampleLocations); 546 ~SampleShadingPositionCase(); 547 548 IterateResult iterate(); 549 550 protected: 551 glu::GLSLVersion m_glslVersion; 552 GLint m_samples; 553 GLboolean m_fixedSampleLocations; 554 555 enum 556 { 557 WIDTH = 8, 558 HEIGHT = 8, 559 MAX_SAMPLES = 8, 560 }; 561 }; 562 563 SampleShadingPositionCase::SampleShadingPositionCase(Context& context, const char* name, const char* description, 564 glu::GLSLVersion glslVersion, GLint samples, 565 GLboolean fixedSampleLocations) 566 : TestCase(context, name, description) 567 , m_glslVersion(glslVersion) 568 , m_samples(samples) 569 , m_fixedSampleLocations(fixedSampleLocations) 570 { 571 DE_ASSERT(glslVersion == glu::GLSL_VERSION_310_ES || glslVersion >= glu::GLSL_VERSION_400); 572 } 573 574 SampleShadingPositionCase::~SampleShadingPositionCase() 575 { 576 } 577 578 SampleShadingPositionCase::IterateResult SampleShadingPositionCase::iterate() 579 { 580 TestLog& log = m_testCtx.getLog(); 581 const glw::Functions& gl = m_context.getRenderContext().getFunctions(); 582 bool isOk = true; 583 584 if (m_glslVersion == glu::GLSL_VERSION_310_ES && 585 !m_context.getContextInfo().isExtensionSupported("GL_OES_sample_variables")) 586 { 587 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "GL_OES_sample_variables"); 588 return STOP; 589 } 590 591 GLint maxSamples; 592 gl.getIntegerv(GL_MAX_SAMPLES, &maxSamples); 593 if (m_samples > maxSamples) 594 { 595 m_testCtx.setTestResult(QP_TEST_RESULT_NOT_SUPPORTED, "Test sample count great than MAX_SAMPLES"); 596 return STOP; 597 } 598 599 // Create a multisample texture, or a regular texture if samples is zero. 600 GLuint tex; 601 gl.genTextures(1, &tex); 602 GLenum target; 603 if (m_samples) 604 { 605 target = GL_TEXTURE_2D_MULTISAMPLE; 606 gl.bindTexture(target, tex); 607 gl.texStorage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, m_samples, GL_RGBA8, WIDTH, HEIGHT, 608 m_fixedSampleLocations); 609 } 610 else 611 { 612 target = GL_TEXTURE_2D; 613 gl.bindTexture(target, tex); 614 gl.texStorage2D(GL_TEXTURE_2D, 1, GL_RGBA8, WIDTH, HEIGHT); 615 } 616 617 // Attach the texture to the framebuffer to render to it. 618 GLuint fboMs; 619 gl.genFramebuffers(1, &fboMs); 620 gl.bindFramebuffer(GL_FRAMEBUFFER, fboMs); 621 gl.framebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, target, tex, 0); 622 gl.viewport(0, 0, WIDTH, HEIGHT); 623 624 // Save all the sample positions for this multisample framebuffer. 625 std::vector<tcu::Vec4> samplePositions; 626 if (m_samples) 627 { 628 samplePositions.resize(m_samples); 629 for (int sample = 0; sample < m_samples; ++sample) 630 { 631 GLfloat position[2]; 632 gl.getMultisamplefv(GL_SAMPLE_POSITION, sample, position); 633 samplePositions[sample] = tcu::Vec4(position[0], position[1], 0.0f, 1.0f); 634 } 635 } 636 637 static deUint16 const quadIndices[] = { 0, 1, 2, 2, 1, 3 }; 638 639 { 640 // Render all the sample positions to each pixel sample. 641 642 static char const* vss = "${VERSION_DECL}\n" 643 "in highp vec2 a_position;\n" 644 "void main()\n" 645 "{\n" 646 " gl_Position = vec4(a_position, 0.0, 1.0);\n" 647 "}\n"; 648 649 static char const* fss = "${VERSION_DECL}\n" 650 "${OES_SV_RQ}" 651 "layout(location = 0) out highp vec4 o_color;\n" 652 "void main()\n" 653 "{\n" 654 " o_color = vec4(gl_SamplePosition, 0, 1);\n" 655 "}\n"; 656 657 glu::ShaderProgram program(m_context.getRenderContext(), 658 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion).c_str(), 659 specializeVersion(fss, m_glslVersion).c_str())); 660 log << program; 661 if (!program.isOk()) 662 { 663 TCU_FAIL("Compile failed"); 664 } 665 666 const float position[] = { 667 -1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, 668 }; 669 670 gl.useProgram(program.getProgram()); 671 672 glu::VertexArrayBinding vertexArrays[] = { 673 glu::va::Float("a_position", 2, 4, 0, &position[0]), 674 }; 675 676 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), 677 &vertexArrays[0], glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0])); 678 679 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw quad"); 680 } 681 682 gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer()); 683 gl.deleteFramebuffers(1, &fboMs); 684 685 // Create a regular non-multisample render buffer to resolve to multisample texture into. 686 // The width is increased to save all samples of the pixel. 687 688 GLsizei width = WIDTH * ((m_samples) ? m_samples : 1); 689 690 GLuint rbo; 691 gl.genRenderbuffers(1, &rbo); 692 gl.bindRenderbuffer(GL_RENDERBUFFER, rbo); 693 gl.renderbufferStorage(GL_RENDERBUFFER, GL_RGBA8, width, HEIGHT); 694 695 GLuint fbo; 696 gl.genFramebuffers(1, &fbo); 697 gl.bindFramebuffer(GL_FRAMEBUFFER, fbo); 698 gl.framebufferRenderbuffer(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_RENDERBUFFER, rbo); 699 gl.viewport(0, 0, width, HEIGHT); 700 701 { 702 // Resolve the multisample texture to the renderbuffer. 703 704 static char const* vss = "${VERSION_DECL}\n" 705 "in highp vec2 a_position;\n" 706 "void main(void)\n" 707 "{\n" 708 " gl_Position = vec4(a_position, 0.0, 1.0);\n" 709 "}\n"; 710 711 static char const* fss = "${VERSION_DECL}\n" 712 "uniform highp sampler2D u_tex;\n" 713 "uniform highp sampler2DMS u_texMS;\n" 714 "uniform int u_samples;\n" 715 "layout(location = 0) out highp vec4 o_color;\n" 716 "void main(void)\n" 717 "{\n" 718 " if (u_samples > 0) {\n" 719 " ivec2 coord = ivec2(int(gl_FragCoord.x) / u_samples, gl_FragCoord.y);\n" 720 " int sampleId = int(gl_FragCoord.x) % u_samples;\n" 721 " o_color = texelFetch(u_texMS, coord, sampleId);\n" 722 " } else {\n" 723 " ivec2 coord = ivec2(gl_FragCoord.x, gl_FragCoord.y);\n" 724 " o_color = texelFetch(u_tex, coord, 0);\n" 725 " }\n" 726 "}\n"; 727 728 glu::ShaderProgram program(m_context.getRenderContext(), 729 glu::makeVtxFragSources(specializeVersion(vss, m_glslVersion).c_str(), 730 specializeVersion(fss, m_glslVersion).c_str())); 731 log << program; 732 if (!program.isOk()) 733 { 734 TCU_FAIL("Compile failed"); 735 } 736 737 static float const position[] = { 738 -1.0f, -1.0f, -1.0f, +1.0f, +1.0f, -1.0f, +1.0f, +1.0f, 739 }; 740 741 gl.useProgram(program.getProgram()); 742 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_samples"), m_samples); 743 if (m_samples > 0) 744 { 745 // only MS sampler needed, TU 1 is not used 746 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_tex"), 1); 747 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_texMS"), 0); 748 } 749 else 750 { 751 // only non-MS sampler needed, TU 1 is not used 752 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_tex"), 0); 753 gl.uniform1i(gl.getUniformLocation(program.getProgram(), "u_texMS"), 1); 754 } 755 756 glu::VertexArrayBinding vertexArrays[] = { 757 glu::va::Float("a_position", 2, 4, 0, &position[0]), 758 }; 759 glu::draw(m_context.getRenderContext(), program.getProgram(), DE_LENGTH_OF_ARRAY(vertexArrays), 760 &vertexArrays[0], glu::pr::TriangleStrip(DE_LENGTH_OF_ARRAY(quadIndices), &quadIndices[0])); 761 762 GLU_EXPECT_NO_ERROR(gl.getError(), "Draw quad"); 763 } 764 765 // Read the renderbuffer pixels and verify we get back what we're expecting. 766 tcu::TextureLevel results(tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), width, 767 HEIGHT); 768 tcu::PixelBufferAccess pixels = results.getAccess(); 769 glu::readPixels(m_context.getRenderContext(), 0, 0, pixels); 770 if (m_samples) 771 { 772 // If m_fixedSampleLocations are used make sure the first pixel's samples 773 // all match the SAMPLE_POSITION state saved earlier. 774 std::set<tcu::Vec4> fixedSampleLocations; 775 if (m_fixedSampleLocations) 776 { 777 for (int sample = 0; sample < m_samples; ++sample) 778 { 779 tcu::Vec4 pixel = pixels.getPixel(sample, 0); 780 fixedSampleLocations.insert(pixel); 781 if (deFloatAbs(pixel.x() - samplePositions[sample].x()) > 0.01 || 782 deFloatAbs(pixel.y() - samplePositions[sample].y()) > 0.01) 783 { 784 785 isOk = false; 786 } 787 } 788 } 789 790 // Verify all samples of every pixel to make sure each position is unique. 791 for (int y = 0; y < HEIGHT; ++y) 792 { 793 for (int x = 0; x < WIDTH; ++x) 794 { 795 std::set<tcu::Vec4> uniquePixels; 796 for (int sample = 0; sample < m_samples; ++sample) 797 { 798 uniquePixels.insert(pixels.getPixel(x * m_samples + sample, y)); 799 } 800 if ((GLint)uniquePixels.size() != m_samples) 801 { 802 isOk = false; 803 } 804 // For the m_fixedSampleLocations case make sure each position 805 // matches the sample positions of pixel(0, 0) saved earlier. 806 if (m_fixedSampleLocations) 807 { 808 if (fixedSampleLocations != uniquePixels) 809 { 810 isOk = false; 811 } 812 } 813 } 814 } 815 } 816 else 817 { 818 // For the non-multisample case make sure all the positions are (0.5,0.5). 819 for (int y = 0; y < pixels.getHeight(); ++y) 820 { 821 for (int x = 0; x < pixels.getWidth(); ++x) 822 { 823 tcu::Vec4 pixel = pixels.getPixel(x, y); 824 if (deFloatAbs(pixel.x() - 0.5f) > 0.01 || deFloatAbs(pixel.y() - 0.5f) > 0.01 || pixel.z() != 0.0f || 825 pixel.w() != 1.0f) 826 { 827 isOk = false; 828 } 829 } 830 } 831 } 832 833 gl.bindFramebuffer(GL_FRAMEBUFFER, m_context.getRenderContext().getDefaultFramebuffer()); 834 gl.deleteFramebuffers(1, &fbo); 835 836 gl.bindRenderbuffer(GL_RENDERBUFFER, 0); 837 gl.deleteRenderbuffers(1, &rbo); 838 839 gl.bindTexture(target, 0); 840 gl.deleteTextures(1, &tex); 841 842 m_testCtx.setTestResult(isOk ? QP_TEST_RESULT_PASS : QP_TEST_RESULT_FAIL, isOk ? "Pass" : "Fail"); 843 return STOP; 844 } 845 846 SampleVariablesTests::SampleVariablesTests(Context& context, glu::GLSLVersion glslVersion) 847 : TestCaseGroup(context, "sample_variables", "Sample Variables tests"), m_glslVersion(glslVersion) 848 { 849 } 850 851 SampleVariablesTests::~SampleVariablesTests() 852 { 853 } 854 855 void SampleVariablesTests::init() 856 { 857 de::Random rnd(m_context.getTestContext().getCommandLine().getBaseSeed()); 858 859 struct Sample 860 { 861 char const* name; 862 GLint samples; 863 } samples[] = { 864 { "samples_0", 0 }, { "samples_1", 1 }, { "samples_2", 2 }, { "samples_4", 4 }, { "samples_8", 8 }, 865 }; 866 867 // sample_variables.extension 868 if (m_glslVersion == glu::GLSL_VERSION_310_ES) 869 { 870 tcu::TestCaseGroup* extensionCaseGroup = new tcu::TestCaseGroup(m_testCtx, "verification", ""); 871 extensionCaseGroup->addChild( 872 new SampleShadingExtensionCase(m_context, "extension", "#extension verification", m_glslVersion)); 873 addChild(extensionCaseGroup); 874 } 875 876 // sample_variables.mask 877 tcu::TestCaseGroup* maskGroup = new tcu::TestCaseGroup(m_testCtx, "mask", "gl_SampleMask tests"); 878 addChild(maskGroup); 879 struct Format 880 { 881 char const* name; 882 GLenum internalFormat; 883 tcu::TextureFormat textureFormat; 884 char const* sampler; 885 char const* outType; 886 } formats[] = { 887 { "rgba8", GL_RGBA8, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNORM_INT8), "sampler2D", 888 "vec4" }, 889 { "rgba8i", GL_RGBA8I, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::SIGNED_INT8), 890 "isampler2D", "ivec4" }, 891 { "rgba8ui", GL_RGBA8UI, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::UNSIGNED_INT8), 892 "usampler2D", "uvec4" }, 893 { "rgba32f", GL_RGBA32F, tcu::TextureFormat(tcu::TextureFormat::RGBA, tcu::TextureFormat::FLOAT), "sampler2D", 894 "vec4" }, 895 }; 896 for (int format = 0; format < DE_LENGTH_OF_ARRAY(formats); ++format) 897 { 898 tcu::TestCaseGroup* maskFormatGroup = new tcu::TestCaseGroup(m_testCtx, formats[format].name, ""); 899 maskGroup->addChild(maskFormatGroup); 900 901 for (int sample = 0; sample < DE_LENGTH_OF_ARRAY(samples); ++sample) 902 { 903 tcu::TestCaseGroup* maskFormatSampleGroup = new tcu::TestCaseGroup(m_testCtx, samples[sample].name, ""); 904 maskFormatGroup->addChild(maskFormatSampleGroup); 905 906 maskFormatSampleGroup->addChild( 907 new SampleShadingMaskCase(m_context, "mask_zero", "", m_glslVersion, formats[format].internalFormat, 908 formats[format].textureFormat, formats[format].sampler, 909 formats[format].outType, samples[sample].samples, 0)); 910 911 for (int mask = 0; mask < SAMPLE_MASKS; ++mask) 912 { 913 std::stringstream ss; 914 ss << "mask_" << mask; 915 maskFormatSampleGroup->addChild(new SampleShadingMaskCase( 916 m_context, ss.str().c_str(), "", m_glslVersion, formats[format].internalFormat, 917 formats[format].textureFormat, formats[format].sampler, formats[format].outType, 918 samples[sample].samples, rnd.getUint32())); 919 } 920 } 921 } 922 923 // sample_variables.position 924 tcu::TestCaseGroup* positionGroup = new tcu::TestCaseGroup(m_testCtx, "position", "gl_SamplePosition tests"); 925 addChild(positionGroup); 926 struct Fixed 927 { 928 char const* name; 929 GLboolean fixedSampleLocations; 930 } fixed[] = { 931 { "non-fixed", GL_FALSE }, { "fixed", GL_TRUE }, 932 }; 933 for (int j = 0; j < DE_LENGTH_OF_ARRAY(fixed); ++j) 934 { 935 tcu::TestCaseGroup* positionFixedGroup = new tcu::TestCaseGroup(m_testCtx, fixed[j].name, ""); 936 positionGroup->addChild(positionFixedGroup); 937 for (int sample = 0; sample < DE_LENGTH_OF_ARRAY(samples); ++sample) 938 { 939 positionFixedGroup->addChild(new SampleShadingPositionCase(m_context, samples[sample].name, "", 940 m_glslVersion, samples[sample].samples, 941 fixed[j].fixedSampleLocations)); 942 } 943 } 944 } 945 946 } // glcts 947
